@ziggs-ai/api-client 0.34.1 → 0.36.0

package/dist/http/PaymentsClient.d.ts

@@ -10,10 +10,6 @@ export interface WalletBalance {
     balance: number;
     availableBalance: number;
 }
-export interface PaymentTransactionView {
-    transactionId?: string;
-    [key: string]: unknown;
-}
 /**
  * A resolved wallet reference (GET /payments/wallets/resolve).
  *
@@ -24,27 +20,6 @@ export interface PaymentTransactionView {
  */
 import type { WalletRef } from '@ziggs-ai/contracts';
 export type { WalletRef };
-export type TransferResult = {
-    status: 'approval_required';
-    approvalId: string | null;
-    expiresAt: string | null;
-    reason: string | null;
-    toWalletId: string;
-    amount: number;
-} | {
-    status: 'transferred';
-    transactionId: string | null;
-    toWalletId: string;
-    amount: number;
-};
-export interface HoldResult {
-    transaction?: PaymentTransactionView;
-    [key: string]: unknown;
-}
-export interface ReleaseResult {
-    transaction?: PaymentTransactionView;
-    [key: string]: unknown;
-}
 /**
  * A payment grant as this rail answers it.
  *
@@ -69,40 +44,14 @@ export interface RevokeGrantResult {
     revoked?: unknown;
     [key: string]: unknown;
 }
-export interface PaymentApproval {
-    approvalId?: string;
-    status?: string;
-    executedTransactionId?: string | null;
-    [key: string]: unknown;
-}
-export type WaitForApprovalResult = {
-    status: 'gone';
-} | {
-    status: 'executed';
-    approval: PaymentApproval;
-    transactionId: string | null;
-} | {
-    status: 'rejected' | 'expired' | 'timeout';
-    approval: PaymentApproval;
-};
-/**
- * Who to pay on a transfer. Kind is declared by the caller — never inferred
- * from id shape. A bare string is only a wallet id (`wal_…`).
- */
-export type TransferPayee = string | {
-    walletId: string;
-} | {
-    agentId: string;
-} | {
-    userId: string;
-};
 /**
  * the one payments client for every surface (agent-sdk, ziggs-mcp,
  * scripts). Consolidates the former agent-sdk private ZiggsPayClient. Wallet
  * ops ride the operator key; agent-impersonated calls send X-Agent-Id and are
- * policy-gated server-side (transfers above threshold return
- * `approval_required`). Wallet-rail grant mutations (issue / attenuate /
- * revoke) live here; grant *listing* is the unified GET /grants.
+ * policy-gated server-side. Points move only when an agreement or a task
+ * settles, and the server does that; there is no standalone movement verb on
+ * this client. Wallet-rail grant mutations (issue / attenuate / revoke) live
+ * here; grant *listing* is the unified GET /grants.
  */
 export declare class PaymentsClient {
     private readonly operatorKey;
@@ -128,60 +77,6 @@ export declare class PaymentsClient {
         userId?: string;
         agentId?: string;
     }): Promise<WalletRef | null>;
-    /**
-     * Resolve `transfer.to` to a wallet id. String form is wallet-only; agent /
-     * user payees must name their kind.
-     */
-    private resolvePayeeWalletId;
-    transfer({ to, amount, idempotencyKey, description, paymentGrantId, agreementId, }: {
-        to: TransferPayee;
-        amount: number;
-        idempotencyKey?: string;
-        description?: string;
-        paymentGrantId?: string;
-        /**
-         * The hire this spend belongs to. Used for attribution, and to prefer that
-         * hire's own grant over a standing one — a preference about which budget is
-         * billed, never about which grants may be spent. That answer is the
-         * server's, and it turns on who gave the grant.
-         */
-        agreementId?: string;
-    }): Promise<TransferResult>;
-    hold({ amount, idempotencyKey, description, paymentGrantId, agreementId, }: {
-        amount: number;
-        idempotencyKey?: string;
-        description?: string;
-        paymentGrantId?: string;
-        /**
-         * The hire this spend belongs to. Used for attribution, and to prefer that
-         * hire's own grant over a standing one — a preference about which budget is
-         * billed, never about which grants may be spent. That answer is the
-         * server's, and it turns on who gave the grant.
-         */
-        agreementId?: string;
-    }): Promise<HoldResult>;
-    /**
-     * Choose the grant that actually covers this spend.
-     *
-     * This used to be `grants[0]` — the first active grant, matched against
-     * nothing. An agent holding both its standing grant and an
-     * agreement-conferred one presented whichever came back first, the backend
-     * correctly refused it against wallet or amount, and the agent was refused a
-     * spend it was genuinely authorized to make.
-     *
-     * The source wallet is read rather than assumed: a grant on some other
-     * wallet cannot authorize money leaving this one, and the agent may hold
-     * grants on a counterparty's wallet from an engagement. A failure to read it
-     * is not fatal — selection then skips the wallet test and the server still
-     * validates, which is the same position we were in before.
-     */
-    private selectPaymentGrant;
-    release({ holdId, action, toWalletId, idempotencyKey, }: {
-        holdId: string;
-        action?: string;
-        toWalletId?: string;
-        idempotencyKey?: string;
-    }): Promise<ReleaseResult>;
     history(params?: {
         limit?: number;
         offset?: number;
@@ -202,27 +97,11 @@ export declare class PaymentsClient {
      * (retired GET /payments/grants), following the cursor to completion.
      */
     listGrants(): Promise<GrantView[]>;
-    createTopUpIntent({ amount, description, currency, }?: {
-        amount?: number;
-        description?: string;
-        currency?: string;
-    }): Promise<unknown>;
-    confirmMockIntent(intentId: string): Promise<unknown>;
     faucet({ amount, description, idempotencyKey, }?: {
         amount?: number;
         description?: string;
         idempotencyKey?: string;
     }): Promise<unknown>;
-    approvals({ status }?: {
-        status?: string;
-    }): Promise<PaymentApproval[]>;
-    getApproval(approvalId: string): Promise<PaymentApproval | null>;
-    decide(approvalId: string, decision: string, note?: string): Promise<unknown>;
-    waitForApproval(approvalId: string, opts?: {
-        pollMs?: number;
-        timeoutMs?: number;
-        signal?: AbortSignal;
-    }): Promise<WaitForApprovalResult>;
     private _request;
     private _get;
     private _post;

package/dist/http/PaymentsClient.js

@@ -1,7 +1,6 @@
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 import { GrantsClient } from './GrantsClient.js';
-import { describeNoGrant, selectPaymentGrant, } from './paymentGrantSelection.js';
 import { throwApiError } from '../shared/apiError.js';
 function randomIdempotencyKey(prefix = 'op') {
     return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
@@ -10,9 +9,10 @@ function randomIdempotencyKey(prefix = 'op') {
  * the one payments client for every surface (agent-sdk, ziggs-mcp,
  * scripts). Consolidates the former agent-sdk private ZiggsPayClient. Wallet
  * ops ride the operator key; agent-impersonated calls send X-Agent-Id and are
- * policy-gated server-side (transfers above threshold return
- * `approval_required`). Wallet-rail grant mutations (issue / attenuate /
- * revoke) live here; grant *listing* is the unified GET /grants.
+ * policy-gated server-side. Points move only when an agreement or a task
+ * settles, and the server does that; there is no standalone movement verb on
+ * this client. Wallet-rail grant mutations (issue / attenuate / revoke) live
+ * here; grant *listing* is the unified GET /grants.
  */
 export class PaymentsClient {
     operatorKey;
@@ -61,139 +61,6 @@ export class PaymentsClient {
         const res = (await this._get(`/payments/wallets/resolve?${params}`));
         return res['wallet'] || null;
     }
-    /**
-     * Resolve `transfer.to` to a wallet id. String form is wallet-only; agent /
-     * user payees must name their kind.
-     */
-    async resolvePayeeWalletId(to) {
-        if (typeof to === 'string') {
-            const id = to.trim();
-            if (!id)
-                throw new Error('transfer: `to` is required');
-            if (id.startsWith('wal_'))
-                return id;
-            throw new Error('transfer: string `to` must be a wallet id (wal_…); pass { agentId } or { userId } for a principal');
-        }
-        if ('walletId' in to && typeof to.walletId === 'string' && to.walletId.trim()) {
-            return to.walletId.trim();
-        }
-        if ('agentId' in to && typeof to.agentId === 'string' && to.agentId.trim()) {
-            const w = await this.resolve({ agentId: to.agentId.trim() });
-            if (!w?.walletId) {
-                throw new Error(`transfer: could not resolve wallet for agent "${to.agentId}"`);
-            }
-            return w.walletId;
-        }
-        if ('userId' in to && typeof to.userId === 'string' && to.userId.trim()) {
-            const w = await this.resolve({ userId: to.userId.trim() });
-            if (!w?.walletId) {
-                throw new Error(`transfer: could not resolve wallet for user "${to.userId}"`);
-            }
-            return w.walletId;
-        }
-        throw new Error('transfer: `to` must be a wallet id (wal_…) or { walletId | agentId | userId }');
-    }
-    async transfer({ to, amount, idempotencyKey, description, paymentGrantId, agreementId, }) {
-        if (to == null || to === '')
-            throw new Error('transfer: `to` is required');
-        if (!(Number.isInteger(amount) && amount > 0))
-            throw new Error('transfer: `amount` must be a positive integer (cents)');
-        // The recipient is resolved BEFORE choosing a grant: an `allowed_recipients`
-        // caveat cannot be checked against a name the client has not resolved yet.
-        const toWalletId = await this.resolvePayeeWalletId(to);
-        // Choose the grant that covers this spend when the caller omitted one.
-        // An explicit id still wins — a caller who names a grant means it.
-        if (this.agentId && !paymentGrantId) {
-            const picked = await this.selectPaymentGrant({ amount, toWalletId, agreementId });
-            if (!picked.grant) {
-                throw new Error(describeNoGrant('transfer', { amount, toWalletId, agreementId }, picked.rejected));
-            }
-            paymentGrantId = picked.grant.grantId;
-        }
-        const result = (await this._post('/payments/transfer', {
-            toWalletId,
-            amount,
-            idempotencyKey: idempotencyKey || randomIdempotencyKey('xfer'),
-            description,
-            paymentGrantId,
-        }));
-        if (result?.['status'] === 'approval_required') {
-            const approval = result['approval'] || {};
-            return {
-                status: 'approval_required',
-                approvalId: approval['approvalId'] || null,
-                expiresAt: approval['expiresAt'] || null,
-                reason: approval['reason'] || 'Amount exceeds auto-approve threshold',
-                toWalletId,
-                amount,
-            };
-        }
-        const tx = result?.['transaction'];
-        return {
-            status: 'transferred',
-            transactionId: tx?.['transactionId'] || null,
-            toWalletId,
-            amount,
-        };
-    }
-    async hold({ amount, idempotencyKey, description, paymentGrantId, agreementId, }) {
-        if (!(Number.isInteger(amount) && amount > 0))
-            throw new Error('hold: `amount` must be a positive integer (cents)');
-        // A hold reserves the owner's money, so it needs a grant like a transfer.
-        // It has no counterparty, so no recipient is offered to the caveats.
-        if (this.agentId && !paymentGrantId) {
-            const picked = await this.selectPaymentGrant({ amount, agreementId });
-            if (!picked.grant) {
-                throw new Error(describeNoGrant('hold', { amount, agreementId }, picked.rejected));
-            }
-            paymentGrantId = picked.grant.grantId;
-        }
-        return (await this._post('/payments/hold', {
-            amount,
-            idempotencyKey: idempotencyKey || randomIdempotencyKey('hold'),
-            description,
-            paymentGrantId,
-        }));
-    }
-    /**
-     * Choose the grant that actually covers this spend.
-     *
-     * This used to be `grants[0]` — the first active grant, matched against
-     * nothing. An agent holding both its standing grant and an
-     * agreement-conferred one presented whichever came back first, the backend
-     * correctly refused it against wallet or amount, and the agent was refused a
-     * spend it was genuinely authorized to make.
-     *
-     * The source wallet is read rather than assumed: a grant on some other
-     * wallet cannot authorize money leaving this one, and the agent may hold
-     * grants on a counterparty's wallet from an engagement. A failure to read it
-     * is not fatal — selection then skips the wallet test and the server still
-     * validates, which is the same position we were in before.
-     */
-    async selectPaymentGrant(spend) {
-        let grants = [];
-        try {
-            grants = await this.listGrants();
-        }
-        catch {
-            return { grant: null, rejected: [] };
-        }
-        let fromWalletId = null;
-        try {
-            fromWalletId = (await this.balance()).walletId;
-        }
-        catch {
-            fromWalletId = null;
-        }
-        return selectPaymentGrant(grants, { ...spend, fromWalletId });
-    }
-    async release({ holdId, action = 'complete', toWalletId, idempotencyKey, }) {
-        return (await this._post(`/payments/release/${holdId}`, {
-            idempotencyKey: idempotencyKey || randomIdempotencyKey('rel'),
-            action,
-            toWalletId,
-        }));
-    }
     async history(params = {}) {
         const q = new URLSearchParams();
         if (params.limit != null)
@@ -224,12 +91,6 @@ export class PaymentsClient {
         const grants = new GrantsClient(this.operatorKey, this.agentId, this.baseUrl, this.laneId);
         return grants.listAllGrants({ scopeKind: 'wallet', health: 'active' });
     }
-    async createTopUpIntent({ amount, description, currency, } = {}) {
-        return this._post('/payments/onramp/intent', { amount, description, currency });
-    }
-    async confirmMockIntent(intentId) {
-        return this._post(`/payments/onramp/mock-confirm/${intentId}`, {});
-    }
     async faucet({ amount, description = 'Faucet', idempotencyKey, } = {}) {
         return this._post('/payments/wallet/fund', {
             amount,
@@ -237,68 +98,6 @@ export class PaymentsClient {
             description,
         });
     }
-    async approvals({ status = 'pending' } = {}) {
-        const res = (await this._get(`/payments/approvals?status=${encodeURIComponent(status)}`));
-        return res['approvals'] || [];
-    }
-    async getApproval(approvalId) {
-        if (!approvalId)
-            throw new Error('getApproval: approvalId is required');
-        try {
-            const res = (await this._get(`/payments/approvals/${approvalId}`));
-            return res?.['approval'] || null;
-        }
-        catch (err) {
-            if (err.status === 404)
-                return null;
-            throw err;
-        }
-    }
-    async decide(approvalId, decision, note = '') {
-        return this._post(`/payments/approvals/${approvalId}/decide`, { decision, note });
-    }
-    async waitForApproval(approvalId, opts = {}) {
-        const pollMs = Math.max(500, opts.pollMs ?? 3_000);
-        const timeoutMs = Math.max(pollMs, opts.timeoutMs ?? 120_000);
-        const signal = opts.signal;
-        const deadline = Date.now() + timeoutMs;
-        const sleep = (ms) => new Promise((resolve, reject) => {
-            const timer = setTimeout(resolve, ms);
-            if (signal) {
-                if (signal.aborted) {
-                    clearTimeout(timer);
-                    reject(new Error('aborted'));
-                    return;
-                }
-                signal.addEventListener('abort', () => {
-                    clearTimeout(timer);
-                    reject(new Error('aborted'));
-                }, { once: true });
-            }
-        });
-        while (true) {
-            if (signal?.aborted)
-                throw new Error('aborted');
-            const approval = await this.getApproval(approvalId);
-            if (!approval)
-                return { status: 'gone' };
-            const s = approval.status;
-            if (s === 'executed')
-                return {
-                    status: 'executed',
-                    approval,
-                    transactionId: approval.executedTransactionId || null,
-                };
-            if (s === 'rejected')
-                return { status: 'rejected', approval };
-            if (s === 'expired')
-                return { status: 'expired', approval };
-            const remaining = deadline - Date.now();
-            if (remaining <= 0)
-                return { status: 'timeout', approval };
-            await sleep(Math.min(pollMs, remaining));
-        }
-    }
     async _request(method, path, body) {
         const init = {
             method,

package/dist/http/index.d.ts

@@ -22,7 +22,7 @@ export type { ContextGrantRecord, ContextGrantScope, ContextGrantScopeKind, Cont
 export { grantCaveat, CONTEXT_GRANT_SCOPE_KINDS, GRANT_SCOPE_KINDS, } from './grants.js';
 export type { GrantView, GrantScopeKind, GrantScopeView, GrantCaveatView, GrantHealth, GrantHolderKind, GrantAccessKind, GrantBasisKind, } from './grants.js';
 export { PaymentsClient } from './PaymentsClient.js';
-export type { PaymentsError, WalletBalance, WalletRef, PaymentTransactionView, TransferPayee, TransferResult, HoldResult, ReleaseResult, PaymentGrantView, PaymentGrantEnvelope, RevokeGrantResult, PaymentApproval, WaitForApprovalResult, } from './PaymentsClient.js';
+export type { PaymentsError, WalletBalance, WalletRef, PaymentGrantView, PaymentGrantEnvelope, RevokeGrantResult, } from './PaymentsClient.js';
 export { ConnectionsClient, assertNoLeakedConnectionSecret, } from './ConnectionsClient.js';
 export type { ConnectionsError, ConnectionProxyParams, ConnectionGrant, ConnectionWithGrants, McpConnectionRequestParams, } from './ConnectionsClient.js';
 export { fetchMyOrgs, resolveOrgSelector, fetchDelegateAccess, fetchHostedAgentAccess, fetchSessionAccess, } from './OrgsClient.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/api-client",
-  "version": "0.34.1",
+  "version": "0.36.0",
   "description": "HTTP and WebSocket client for the Ziggs backend API",
   "type": "module",
   "main": "dist/index.js",

package/dist/http/paymentGrantSelection.d.ts

@@ -1,58 +0,0 @@
-import { type GrantView } from './grants.js';
-/**
- * Which grant to present for a spend, and — when none fits — why each candidate
- * did not.
- *
- * The client used to take `grants[0]` from the active list. It matched nothing
- * else: not the source wallet, not the amount, not the agreement the spend
- * belongs to. An agent holding both its standing grant and an agreement-conferred
- * one presented whichever came back first, the backend correctly refused it
- * against wallet or amount, and the agent was refused a spend it was genuinely
- * authorized to make.
- *
- * Selection is a pure function of the grants and the spend so it can be tested
- * without a server, and so the refusal can name what it considered.
- */
-export interface SpendShape {
-    /** The wallet the money leaves. A grant on another wallet cannot authorize it. */
-    fromWalletId?: string | null;
-    /** Cents. Checked against `max_amount`. */
-    amount: number;
-    /** The wallet receiving it, when known. Checked against `allowed_recipients`. */
-    toWalletId?: string | null;
-    /** The engagement this spend belongs to, when the caller names one. */
-    agreementId?: string | null;
-}
-export interface RejectedGrant {
-    grantId: string;
-    reason: string;
-}
-export interface GrantSelection {
-    grant: GrantView | null;
-    /** Every grant that was looked at and did not fit, with the reason. */
-    rejected: RejectedGrant[];
-}
-/**
- * Pick the grant to present, preferring the one that belongs to the engagement.
- *
- * Order among grants that all fit: the agreement's own grant first when the
- * spend names one, then the standing grant. A standing grant is the buyer
- * bootstrap and the right default; reaching for it while an agreement grant
- * covers the same spend would bill the wrong budget.
- *
- * This is a preference, never a fence. Every grant here is already one the
- * server said this wake may spend, so picking a different one cannot reach
- * another party's authority — it would only bill the wrong budget of the same
- * party. That is why the mismatch is no longer a rejection above.
- */
-export declare function selectPaymentGrant(grants: readonly GrantView[], spend: SpendShape): GrantSelection;
-/**
- * The sentence an agent gets when nothing fits.
- *
- * It names every grant considered and why each was not it, because "no payment
- * grant" is a condition and an agent cannot act on a condition — it retries,
- * and every retry is a full model call. Which ceiling was in the way is the
- * thing that tells the agent whether to ask for a bigger grant, name the
- * agreement, or stop.
- */
-export declare function describeNoGrant(verb: string, spend: SpendShape, rejected: readonly RejectedGrant[]): string;

package/dist/http/paymentGrantSelection.js

@@ -1,121 +0,0 @@
-import { grantCaveat } from './grants.js';
-/**
- * A caveat off a grant that may not carry the array at all.
- *
- * `grantCaveat` assumes `caveats` is populated, which the unified list read
- * does. A caller handing us a partial view should get "no such caveat", not a
- * crash — this runs on the spend path, where throwing would turn a missing
- * field into a refused payment.
- */
-function caveatValue(grant, type) {
-    const caveats = grant.caveats;
-    if (!Array.isArray(caveats))
-        return undefined;
-    return grantCaveat(grant, type);
-}
-function numericCaveat(grant, type) {
-    const raw = caveatValue(grant, type);
-    return typeof raw === 'number' && Number.isFinite(raw) ? raw : null;
-}
-function recipientCaveat(grant) {
-    const raw = caveatValue(grant, 'allowed_recipients');
-    if (!Array.isArray(raw))
-        return null;
-    const ids = raw.filter((r) => typeof r === 'string');
-    return ids.length ? ids : null;
-}
-/**
- * Why this grant cannot authorize this spend, or null if it can.
- *
- * `daily_budget` is deliberately not checked. It is a ceiling on spend already
- * made, which only the server can see — guessing here would refuse a grant that
- * would have worked. The server validates it inside the same transaction as the
- * ledger write, which is the only place the answer is not already stale.
- */
-function whyNot(grant, spend) {
-    // A stated kind that is not `wallet` is disqualifying. An ABSENT one is not:
-    // `listGrants` asks the server for `scopeKind: 'wallet'`, so the rail has
-    // already answered, and treating a field the response did not populate as a
-    // wrong answer would refuse every grant. Same reading as an unread source
-    // wallet below — absence means unknown, never no.
-    if (grant.scope?.kind && grant.scope.kind !== 'wallet') {
-        return `is a ${grant.scope.kind} grant, not a wallet grant`;
-    }
-    if (spend.fromWalletId && grant.scope?.id && grant.scope.id !== spend.fromWalletId) {
-        return `is on wallet ${grant.scope.id}, and this spend leaves ${spend.fromWalletId}`;
-    }
-    const maxAmount = numericCaveat(grant, 'max_amount');
-    if (maxAmount !== null && spend.amount > maxAmount) {
-        return `caps a single spend at ${maxAmount}, and this one is ${spend.amount}`;
-    }
-    const allowed = recipientCaveat(grant);
-    if (allowed && spend.toWalletId && !allowed.includes(spend.toWalletId)) {
-        return `may only pay ${allowed.join(', ')}, and this one pays ${spend.toWalletId}`;
-    }
-    // A grant's agreement is NOT checked here, deliberately.
-    //
-    // It used to be refused when it did not match the spend's agreement, which
-    // made a customer's own grant unusable inside their second hire of the same
-    // agent, and made a standing grant unusable on any spend that named a deal.
-    // Whether a grant may be spent at all is the server's answer, and it turns on
-    // who GAVE the grant against who the agent is acting for — not on which of
-    // that party's deals is running. A list the server answered for this wake
-    // holds only grants it may spend, so there is nothing left to refuse here.
-    //
-    // The agreement still decides the ORDER below, which is a budget preference
-    // rather than a question of authority.
-    return null;
-}
-/**
- * Pick the grant to present, preferring the one that belongs to the engagement.
- *
- * Order among grants that all fit: the agreement's own grant first when the
- * spend names one, then the standing grant. A standing grant is the buyer
- * bootstrap and the right default; reaching for it while an agreement grant
- * covers the same spend would bill the wrong budget.
- *
- * This is a preference, never a fence. Every grant here is already one the
- * server said this wake may spend, so picking a different one cannot reach
- * another party's authority — it would only bill the wrong budget of the same
- * party. That is why the mismatch is no longer a rejection above.
- */
-export function selectPaymentGrant(grants, spend) {
-    const rejected = [];
-    const fitting = [];
-    for (const grant of grants) {
-        const reason = whyNot(grant, spend);
-        if (reason)
-            rejected.push({ grantId: grant.grantId, reason });
-        else
-            fitting.push(grant);
-    }
-    if (fitting.length === 0)
-        return { grant: null, rejected };
-    // Explicit both ways, because the deal is no longer a fence: until it was
-    // removed, a deal-bound grant simply never reached this list on a spend that
-    // named nothing, so "prefer the standing grant" happened by accident of the
-    // rejection. Now it has to be said.
-    const standing = fitting.find((g) => !g.agreementId);
-    const preferred = spend.agreementId
-        ? (fitting.find((g) => g.agreementId === spend.agreementId) ?? standing)
-        : standing;
-    return { grant: preferred ?? fitting[0], rejected };
-}
-/**
- * The sentence an agent gets when nothing fits.
- *
- * It names every grant considered and why each was not it, because "no payment
- * grant" is a condition and an agent cannot act on a condition — it retries,
- * and every retry is a full model call. Which ceiling was in the way is the
- * thing that tells the agent whether to ask for a bigger grant, name the
- * agreement, or stop.
- */
-export function describeNoGrant(verb, spend, rejected) {
-    if (rejected.length === 0) {
-        return (`${verb}: you hold no active payment grant, so this spend cannot be ` +
-            `authorized. The wallet owner issues one; nothing you can do from here.`);
-    }
-    const lines = rejected.map((r) => `  - ${r.grantId} ${r.reason}`).join('\n');
-    return (`${verb}: none of your ${rejected.length} active payment grant(s) covers ` +
-        `this spend of ${spend.amount}.\n${lines}`);
-}