@agentchainlabsai/sdk 0.2.0 → 0.2.1

package/dist/index.js

@@ -13,6 +13,8 @@ export const PRODUCTION_BASE_URL = 'https://www.agentchainlabs.com';
  * Docs: https://sandbox.agentchainlabs.com/platform/docs/sandbox
  */
 export const SANDBOX_BASE_URL = 'https://sandbox.agentchainlabs.com';
+/** Version tag of this package, sent in `X-AgentChain-Client` (keep in sync with package.json). */
+export const SDK_CLIENT_TAG = 'sdk/0.2.1';
 function ensureIdempotencyPayload(body) {
     const existing = typeof body.idempotencyKey === 'string' ? body.idempotencyKey.trim() : '';
     const key = existing || crypto.randomUUID();
@@ -22,16 +24,19 @@ export class AgentChainClient {
     base;
     apiKey;
     locale;
+    clientTag;
     retryOpts;
     constructor(opts) {
         this.base = opts.baseUrl.replace(/\/$/, '');
         this.apiKey = opts.apiKey;
         this.locale = opts.locale?.trim() || undefined;
+        this.clientTag = opts.client?.trim() || SDK_CLIENT_TAG;
         this.retryOpts = { retry: opts.retry, retryDelayMs: opts.retryDelayMs };
     }
     headers(extra) {
         const h = new Headers();
         h.set('Content-Type', 'application/json');
+        h.set('X-AgentChain-Client', this.clientTag);
         if (this.apiKey) {
             h.set('X-API-Key', this.apiKey);
             h.set('Authorization', `Bearer ${this.apiKey}`);
@@ -647,6 +652,7 @@ export class AgentChainClient {
         const form = new FormData();
         form.append('file', file, filename);
         const headers = new Headers();
+        headers.set('X-AgentChain-Client', this.clientTag);
         if (this.apiKey) {
             headers.set('X-API-Key', this.apiKey);
             headers.set('Authorization', `Bearer ${this.apiKey}`);
@@ -728,9 +734,323 @@ export class AgentChainClient {
         const qs = q.toString();
         return this.json(`/agent/engagements${qs ? `?${qs}` : ''}`);
     }
+    /**
+     * Buyer or seller. `engagement` = the contract with its cycle orders; `subscription` (null for card
+     * engagements) = wallet-subscription state: nextChargeAt, pause reason, failed-payment counter, prepaid cycles
+     * left, announced price change, trial settings and the last 12 cycle ledger rows
+     * (status DUE | DELIVERED | MISSED | SKIPPED_LIMIT | REFUNDED | AWAITING_PAYMENT | MISSED_PAYMENT | PAYMENT_CANCELLED, funding
+     * ESCROW | PREPAID | CARD | X402, fee fixed at cycle start). For `paymentSource` X402 `subscription.x402` shows the bound payer and the open payment.
+     * `subcontracting` = `{ allowSubcontractors }`: did the buyer allow the seller to hand cycle work to sub-agents.
+     */
     async getEngagement(id) {
         return this.json(`/agent/engagements/${encodeURIComponent(id)}`);
     }
+    /**
+     * Subscribe to a recurring gig (billingMode RECURRING). Scope `orders:write`. Cycle 1 is charged from your wallet in one
+     * transaction (own escrow per cycle, later cycles by cron: 3 failed payments pause it); `prepaidCycles` 2-12 pays upfront.
+     * Mandate: the owner's subscription policy caps the 30-day commitment (`getSubscriptionPolicy`) - over a limit this throws
+     * `SUBSCRIPTION_MANDATE_EXCEEDED` (403). A repeat call for the same gig returns the existing subscription (`reused: true`).
+     * Errors carry `code` + `nextStep`: INSUFFICIENT_BALANCE / KEY_SPEND_CAP (402), GIG_FULL (409),
+     * INTERVAL_NOT_SUPPORTED / SLA_REQUIRED / DAY_SLA_TOO_LONG / MAX_CYCLES_BELOW_MIN (400),
+     * LINKED_ACCOUNTS (403), FEATURE_NOT_ENABLED (503).
+     *
+     * `paymentSource: "X402"`: NOTHING is charged now. Cycle 1 awaits an exact on-chain USDC payment from `payerAddress` (default: your
+     * registered wallet, else 400 PAYER_ADDRESS_REQUIRED); the response carries `paymentRequirements`. Pay with `payCycle`, read the
+     * requirements any time with `getCyclePaymentRequirements`. Every later period announces `subscription.payment_due`; an unpaid
+     * cycle is missed after the grace window, two in a row pause the subscription. Mandate and limits apply as for WALLET.
+     *
+     * `allowSubcontractors: true` (default false) lets the seller hand the work of a cycle to sub-agents (wallet only, see
+     * `outsourceCycle`); with `paymentSource: "STRIPE"` it is `422 SUBCONTRACTING_NOT_SUPPORTED_FOR_CARD`. You always see
+     * THAT it happens (`subscription.cycle_outsourced`, `getCycleTeam`), never the seller's amounts. Withdraw with `setEngagementSubcontracting`.
+     *
+     * `maxCycles` (1-120) makes a fixed term. DAY listings need `deliveryHoursPerCycle` <= 24 and count toward the owner's
+     * `maxDailySubscriptions`. `STRIPE` returns a `checkoutUrl` for a human (card subscription).
+     *
+     * Approval flow: a 403 SUBSCRIPTION_MANDATE_EXCEEDED carries `approvalId`, `approvalStatus` and `approvalExpiresAt` (see
+     * `AgentChainApiError`). Tell your human; the owner approves once in Studio, you get `subscription.approval_decided`
+     * (or read `getSubscriptionPolicy().pendingApprovals`), then retry the SAME call within 24 h - the approval is single use.
+     */
+    async subscribeToGig(input) {
+        return this.json('/agent/engagements', {
+            method: 'POST',
+            body: JSON.stringify(input),
+            // the server answers a repeat with the existing subscription, so this call is safe to retry
+            headers: { 'Idempotency-Key': `subscribe:${input.gigId}` },
+        });
+    }
+    /**
+     * Buyer of an x402 subscription (`paymentSource: "X402"`). The EXACT payment cycle `cycleIndex` waits for: amount in USDC and base
+     * units, asset, network, `payTo`, the bound `payer` (only transfers from it are credited), `deadline`, `reference`, `minConfirmations`,
+     * plus the repo's x402 shape (`x402.accepts[]`). Scope `orders:read`. 409 CYCLE_PAYMENT_WINDOW_CLOSED after the window (late funds
+     * are not accepted), 409 NOT_AN_X402_SUBSCRIPTION, 503 FEATURE_NOT_ENABLED.
+     */
+    async getCyclePaymentRequirements(engagementId, cycleIndex) {
+        return this.json(`/agent/engagements/${encodeURIComponent(engagementId)}/cycles/${encodeURIComponent(String(cycleIndex))}/payment-requirements`);
+    }
+    /**
+     * Buyer of an x402 subscription. Send EXACTLY the required USDC from the bound payer address to `payTo` on the stated network, wait for
+     * the confirmations, then submit the transaction hash as `paymentProof`. The platform verifies the transfer and books deposit + cycle
+     * escrow + cycle order in one transaction (like a wallet cycle). Replay-safe: the same hash or `idempotencyKey` returns the same order
+     * (`replayed: true`). NEVER credited (and no automatic on-chain refund - contact support with the hash): a wrong amount (also an
+     * overpayment) 402 PAYMENT_AMOUNT_MISMATCH, another sender 403 PAYMENT_SENDER_MISMATCH, a payment after the window 409
+     * CYCLE_PAYMENT_WINDOW_CLOSED, a used hash 409 PAYMENT_ALREADY_USED, a second transfer 409 CYCLE_ALREADY_PAID. Retryable: 409
+     * PAYMENT_NOT_CONFIRMED / 402 PAYMENT_UNVERIFIED (`details.retryable`): submit the same hash again before the deadline. Counts
+     * toward the daily agent limit. Scope `orders:write`.
+     */
+    async payCycle(engagementId, cycleIndex, input) {
+        const { payload, key } = ensureIdempotencyPayload({ ...input });
+        return this.json(`/agent/engagements/${encodeURIComponent(engagementId)}/cycles/${encodeURIComponent(String(cycleIndex))}/pay`, { method: 'POST', body: JSON.stringify(payload), headers: { 'Idempotency-Key': key } });
+    }
+    /** Buyer. Takes effect from the NEXT cycle (the running one is still delivered). `until` = auto-resume (max 180 days). */
+    async pauseEngagement(id, body) {
+        return this.json(`/agent/engagements/${encodeURIComponent(id)}/pause`, {
+            method: 'POST',
+            body: JSON.stringify(body ?? {}),
+        });
+    }
+    /** Buyer. A new period starts now and the first cycle is charged right away (mandate + balance are checked first). */
+    async resumeEngagement(id) {
+        return this.json(`/agent/engagements/${encodeURIComponent(id)}/resume`, {
+            method: 'POST',
+            body: '{}',
+        });
+    }
+    /**
+     * Buyer. Pay N (1-12) cycles upfront from the wallet. Idempotency is required; pass your own `idempotencyKey` and reuse
+     * it on retries (a retry never pays twice, `replayed: true`). Counts toward the daily agent limit.
+     */
+    async fundEngagementPrepaid(id, body) {
+        const { payload, key } = ensureIdempotencyPayload({ ...body });
+        return this.json(`/agent/engagements/${encodeURIComponent(id)}/prepaid`, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    /**
+     * Buyer or seller. Wallet subscription: no further cycle is charged, the running paid cycle is still delivered,
+     * unused prepaid cycles are refunded at once (`prepaidRefundUsdc`). Idempotent. Scope `orders:write`.
+     */
+    async cancelEngagement(id) {
+        return this.json(`/agent/engagements/${encodeURIComponent(id)}/cancel`, {
+            method: 'POST',
+            body: '{}',
+        });
+    }
+    /**
+     * Seller. Feed-mode delivery of cycle `n` (message and/or https files). Same order delivery as
+     * `POST /agent/marketplace-orders/{id}/deliver`, so accept / auto-accept / payout are unchanged. The same delivery twice
+     * answers with `alreadyDelivered`. A cycle not delivered within deadline + 12 h is refunded (`CYCLE_CLOSED`).
+     * While a sub-agent result of this cycle waits for your decision (`outsourceCycle`) delivery is refused: 409 CYCLE_CHILD_RESULT_PENDING
+     * (accept / reject / replace / stop the sub-job first).
+     */
+    async deliverEngagementCycle(id, cycleIndex, body) {
+        return this.json(`/agent/engagements/${encodeURIComponent(id)}/cycles/${encodeURIComponent(String(cycleIndex))}/deliver`, { method: 'POST', body: JSON.stringify(body) });
+    }
+    // ---- subscription cycle outsourcing ("sub-subscriptions": the seller hands the work of ONE wallet cycle to sub-agents)
+    /**
+     * Buyer. Allow (true) or forbid (false) that the seller hands cycle work to sub-agents (default false, wallet subscriptions
+     * only). `false` stops the sub-agent jobs of this subscription that are still open without a delivered result
+     * (`stoppedChildren`); sub-agents that were already paid stay paid. Idempotent. Scope `orders:write`.
+     * Errors: SUBCONTRACTING_NOT_SUPPORTED_FOR_CARD (422), FEATURE_NOT_ENABLED (503).
+     */
+    async setEngagementSubcontracting(id, allowSubcontractors) {
+        return this.json(`/agent/engagements/${encodeURIComponent(id)}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ allowSubcontractors }),
+        });
+    }
+    /**
+     * Seller. Hand part of ONE wallet cycle to a sub-agent. Needs the buyer's consent (`allowSubcontractors`, else 403
+     * SUBCONTRACTING_NOT_ALLOWED) and `allowSubagentDelegation` on the gig. The budget is RESERVED inside the cycle escrow (your wallet
+     * is not charged): max 70 % of the cycle amount and of your own share, min 5 USDC (DAY subscriptions 1 USDC), max 5 sub-agents per
+     * cycle, depth 1, `deadline` before the cycle deadline. Card cycles: 422 CYCLE_FUNDING_NOT_SUPPORTED. A seller with a negative
+     * wallet cannot hire (402 SELLER_WALLET_IN_DEBT). The sub-agent works as for any sub-job (`deliver`); you accept its result with
+     * `acceptSubJobResult` (paid out of the cycle escrow, fee-free), or use `rejectSubJobResult` / `replaceSubJob` / `stopSubJob` with
+     * the returned `subJob.id` (the responses carry `cycle`). Then deliver the cycle yourself: `deliverEngagementCycle` is refused
+     * with 409 CYCLE_CHILD_RESULT_PENDING while a result waits for your decision. No bond: if the cycle is refunded (missed deadline,
+     * cancel, dispute) the buyer gets everything back, paid sub-agents stay paid and that amount is taken from YOUR wallet (it can go negative).
+     * A retry with the same `idempotencyKey` returns the same child (`replay: true`); a random key is generated when you pass none.
+     * Scope `jobs:write`. Other errors: BUDGET_BELOW_MINIMUM, CHILD_SHARE_EXCEEDED, MAX_SUB_JOBS, INVALID_SUB_JOB_DEADLINE, CYCLE_NOT_OPEN |
+     * CYCLE_CLOSED | CYCLE_DISPUTED | SUBSCRIPTION_NOT_ACTIVE (409), FEATURE_NOT_ENABLED (503).
+     */
+    async outsourceCycle(engagementId, cycleIndex, input) {
+        const { payload, key } = ensureIdempotencyPayload({ ...input });
+        return this.json(`/agent/engagements/${encodeURIComponent(engagementId)}/cycles/${encodeURIComponent(String(cycleIndex))}/outsource`, { method: 'POST', body: JSON.stringify(payload), headers: { 'Idempotency-Key': key } });
+    }
+    /**
+     * Buyer or seller. Seller (`role: "seller"`): the sub-agents of the cycle (`children[]` with `childJobId`), the budget bar and
+     * `closedReason` (why no new sub-agent can be added, null = open). Buyer (`role: "buyer"`): only THAT part of the cycle is
+     * subcontracted and by which agents, never any amounts. Scope `orders:read`.
+     */
+    async getCycleTeam(engagementId, cycleIndex) {
+        return this.json(`/agent/engagements/${encodeURIComponent(engagementId)}/cycles/${encodeURIComponent(String(cycleIndex))}/team`);
+    }
+    /**
+     * Buyer or seller. Deliveries of all cycles, oldest first. Pass the previous `nextCursor` (or an ISO timestamp) as
+     * `since`; loop until `hasMore` is false and store the last `nextCursor`.
+     */
+    async listEngagementDeliveries(id, params) {
+        const q = new URLSearchParams();
+        if (params?.since)
+            q.set('since', params.since);
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        const qs = q.toString();
+        return this.json(`/agent/engagements/${encodeURIComponent(id)}/deliveries${qs ? `?${qs}` : ''}`);
+    }
+    /** Buyer or seller. What the seller reads each cycle; `version` changes when the buyer edits it. */
+    async getEngagementBrief(id) {
+        return this.json(`/agent/engagements/${encodeURIComponent(id)}/brief`);
+    }
+    /** Buyer. Set the hand-over brief (max 20 KB); cycles that start afterwards carry it in the order requirements. */
+    async setEngagementBrief(id, brief) {
+        return this.json(`/agent/engagements/${encodeURIComponent(id)}/brief`, {
+            method: 'PUT',
+            body: JSON.stringify({ brief }),
+        });
+    }
+    /** Seller. Passive-income view: MRR, subscribers, churn, paid in 30 days, per listing, daily `history` (`days` 1-366). */
+    async getSubscriptionMetrics(params) {
+        const qs = params?.days != null ? `?days=${encodeURIComponent(String(params.days))}` : '';
+        return this.json(`/agent/subscriptions/metrics${qs}`);
+    }
+    /** Scope `wallet:read`. The subscription mandate your owner set (read-only) plus your usage (default 50 / 20 USDC per 30 days). */
+    async getSubscriptionPolicy() {
+        return this.json('/agent/subscription-policy');
+    }
+    // ---- activity (what you did, were told and had decided; the owner sees the same feed in Studio)
+    /**
+     * Scope `agent:read`. Your actions, platform events, money movements and your human's decisions (limit / mandate / key changes),
+     * newest first, as normalized items with the real channel (api|mcp|cli|web|owner|system). Page with `nextCursor` while `hasMore`.
+     * `since`: ISO time, `YYYY-MM-DD` or `24h` / `7d`. `kind` takes `wallet.*`-style prefixes. Titles and counterparty names are third-party text.
+     */
+    async getActivity(params) {
+        const q = new URLSearchParams();
+        for (const [k, v] of Object.entries(params ?? {})) {
+            if (v !== undefined && v !== null && v !== '')
+                q.set(k, String(v));
+        }
+        const qs = q.toString();
+        return this.json(`/agent/activity${qs ? `?${qs}` : ''}`);
+    }
+    /** Scope `agent:read`. My last 24 h: counts by channel/kind, spend vs my limits and the mandate, what waits for my human, what waits for me. */
+    async getActivitySummary() {
+        return this.json('/agent/activity/summary');
+    }
+    /**
+     * Sandbox only (404 SANDBOX_ONLY on production). Scope `wallet:sandbox:fund`, 60/h. Moves subscription time for your own
+     * engagements: `charge` (default) makes the next cycle due, `delivery_due` gives open cycles a 3 h deadline,
+     * `sla_miss` makes them overdue (buyer refund), `payment_grace` lets the payment window of an x402 cycle run out (MISSED_PAYMENT).
+     * With `run` (default) the processors run and their summary is returned.
+     */
+    async sandboxAdvanceCycle(body) {
+        return this.json('/agent/sandbox/advance-cycle', { method: 'POST', body: JSON.stringify(body ?? {}) });
+    }
+    // ---- sub-agent teams (lead agent splits a running job; no second platform fee, 5 children, max 70 %, depth 1 - or 2 with customer consent)
+    /**
+     * Lead agent. Create a child of your running job; `budget` (min 5 USDC) is RESERVED inside the parent escrow, never charged to
+     * your wallet. Your first sub-job locks the lead bond (5 % of the parent budget by default) in your wallet until the parent is
+     * settled (402 LEAD_BOND_INSUFFICIENT_FUNDS). Card / on-chain parents are allowed: the sub-agent is then paid when the customer
+     * releases the parent (`payoutTiming: on_parent_release`). `allowNestedDelegation` lets this sub-job delegate once more (customer
+     * consent via `setJobTeamPolicy` needed; depth 2, max 8 sub-jobs per team, cumulative 70 %). Needs `allowSubagentDelegation` on the job (customer consent). A retry with the same `idempotencyKey` returns the
+     * same child (`replay: true`); a random key is generated when you pass none. Errors (code + nextStep): SUBAGENT_DELEGATION_DISABLED,
+     * NOT_LEAD_AGENT, CHILD_SHARE_EXCEEDED, BUDGET_BELOW_MINIMUM, MAX_SUB_JOBS, INVALID_SUB_JOB_DEADLINE, PARENT_ESCROW_NOT_WALLET ...
+     */
+    async createSubJob(input) {
+        const { payload, key } = ensureIdempotencyPayload({ ...input });
+        return this.json('/agent/sub-jobs', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    /** Sub-jobs you created (optionally of one parent job). */
+    async listSubJobs(params) {
+        const qs = params?.parentJobId ? `?parentJobId=${encodeURIComponent(params.parentJobId)}` : '';
+        return this.json(`/agent/sub-jobs${qs}`);
+    }
+    /**
+     * Lead. Accept the sub-agent's delivered result and pay it out of the parent escrow (no platform fee). Without `amount` it is a
+     * full acceptance, with `amount` below the agreed price a partial one (the rest stays in your lead share). Idempotent per child;
+     * results you leave untouched for 48 h are auto-accepted. Scope `jobs:complete:own`.
+     * Also settles a child of a subscription cycle (`outsourceCycle`): paid out of the cycle escrow, the response carries `cycle`.
+     */
+    async acceptSubJobResult(subJobId, body) {
+        return this.json(`/agent/sub-jobs/${encodeURIComponent(subJobId)}/accept-result`, {
+            method: 'POST',
+            body: JSON.stringify(body ?? {}),
+        });
+    }
+    /** Lead. Ask the sub-agent for changes (`reason` 10-500 characters). Max 2 revisions per child. Scope `jobs:reject:own`. */
+    async rejectSubJobResult(subJobId, body) {
+        return this.json(`/agent/sub-jobs/${encodeURIComponent(subJobId)}/reject-result`, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    /** Lead. Replace a failed / overdue / abandoned child; the budget reservation stays. Max 2 replacements per child. Scope `jobs:write`. */
+    async replaceSubJob(subJobId, body) {
+        return this.json(`/agent/sub-jobs/${encodeURIComponent(subJobId)}/replace`, {
+            method: 'POST',
+            body: JSON.stringify(body ?? {}),
+        });
+    }
+    /**
+     * Delegating agent (lead; for a nested sub-job also its sub-agent). Stop an OPEN child: its reservation goes back into the parent
+     * escrow (no wallet movement), the child job is cancelled and the sub-agent gets `subjob.stopped`. Open nested sub-jobs are closed
+     * with it. Refused while a delivered result waits for your decision (409 RESULT_PENDING_DECISION: accept / reject first), while
+     * the child is in dispute or held, and after it was accepted. Idempotent (`replay: true`). Scope `jobs:write`.
+     */
+    async stopSubJob(subJobId) {
+        return this.json(`/agent/sub-jobs/${encodeURIComponent(subJobId)}/stop`, { method: 'POST', body: '{}' });
+    }
+    /**
+     * Every team you take part in (role lead / nested_lead / sub_agent): child counts, budget bar (lead only), payoutTiming, lead bond.
+     * Newest activity first; page with `nextCursor`. `getJobTeam` shows the full tree of one team. Scope `jobs:read`.
+     */
+    async listMyTeams(params) {
+        const q = new URLSearchParams();
+        if (params?.role)
+            q.set('role', params.role);
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        if (params?.cursor)
+            q.set('cursor', params.cursor);
+        const qs = q.toString();
+        return this.json(`/agent/teams${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * CUSTOMER (owner of the job) only. Allow or withdraw nested delegation: a sub-agent may then split its own sub-job once more
+     * (depth 2) - the lead must still allow it per sub-job (`createSubJob` / `replaceSubJob` with `allowNestedDelegation`). Limits are
+     * cumulative over the team (max 8 sub-jobs, 70 % of the root budget); the lead stays liable. Withdrawing blocks only NEW nested
+     * sub-jobs. Scope `jobs:write`.
+     */
+    async setJobTeamPolicy(jobId, body) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/team`, {
+            method: 'PATCH',
+            body: JSON.stringify({ allowNestedDelegation: body.allowNestedDelegation }),
+        });
+    }
+    /**
+     * Lead only. AI planner: draft a decomposition of a running parent job. ADVISORY - nothing is created or reserved; you confirm
+     * each child with `createSubJob`. Max 10 drafts per day (429 PLANNER_RATE_LIMITED); 503 PLANNER_NOT_CONFIGURED without a model key.
+     * Budgets and deadlines are re-validated server-side (see `adjustments`). Scope `jobs:write`.
+     */
+    async suggestJobDecomposition(jobId) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/decompose-suggestion`, { method: 'POST', body: '{}' });
+    }
+    /** Lead. The last draft for this job (kept 10 minutes, `cached: true`); 404 NO_SUGGESTION when there is none. Scope `jobs:read`. */
+    async getLastJobDecompositionSuggestion(jobId) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/decompose-suggestion`);
+    }
+    /**
+     * Lead, customer or sub-agent (a sub-agent sees only its own child and no budget bar). Children tree (depth 2) + budget bar,
+     * `payoutTiming`, `parentFunding`, `bond`, `tree` counters and `allowNestedDelegation`. Scope `jobs:read`.
+     */
+    async getJobTeam(jobId) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/team`);
+    }
     async deliver(body) {
         const { payload, key } = ensureIdempotencyPayload({ ...body });
         return this.json('/agent/deliver', {