@agentchainlabsai/sdk 0.0.0-stage → 0.2.1

package/dist/index.js

@@ -0,0 +1,1578 @@
+/**
+ * AgentChain Agent API v1 — thin HTTP client (zero runtime deps).
+ * Contract: same as OpenAPI `docs/openapi/agent-api.yaml` and MCP tools.
+ */
+import { apiErrorFromResponse, fetchJson } from './http.js';
+export { AgentChainApiError, apiErrorFromResponse, fetchJson, isIdempotentRequest, nonJsonMessage, DEFAULT_RETRY_DELAY_MS, } from './http.js';
+export { verifyWebhookSignature, standardWebhookKeyBytes, legacyWebhookKeyBytes, } from './webhooks.js';
+/** Production origin. */
+export const PRODUCTION_BASE_URL = 'https://www.agentchainlabs.com';
+/**
+ * Sandbox origin — same API with test money only (Stripe test mode, test USDC, demo bots).
+ * Keys minted there start with `ag_test_` and are rejected by production (401 TEST_KEY_ON_PRODUCTION).
+ * 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();
+    return { payload: { ...body, idempotencyKey: key }, key };
+}
+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}`);
+        }
+        if (this.locale) {
+            h.set('X-Locale', this.locale);
+        }
+        if (extra) {
+            const ex = new Headers(extra);
+            ex.forEach((value, key) => {
+                h.set(key, value);
+            });
+        }
+        return h;
+    }
+    async json(path, init) {
+        const url = `${this.base}/api/v1${path}`;
+        const { res, body } = await fetchJson(url, {
+            ...init,
+            headers: this.headers(init?.headers),
+        }, this.retryOpts);
+        if (!res.ok) {
+            const err = body;
+            throw apiErrorFromResponse(res, body, err.error || err.code || `HTTP ${res.status}`);
+        }
+        return body;
+    }
+    /** Public metadata — no API key required */
+    async discovery() {
+        const { res, body } = await fetchJson(`${this.base}/api/v1/agent/discovery`, { headers: { Accept: 'application/json' } }, this.retryOpts);
+        if (!res.ok) {
+            const err = body;
+            throw apiErrorFromResponse(res, body, err.error || err.code || `HTTP ${res.status}`);
+        }
+        return body;
+    }
+    /** Mint a Relay presentation JWT. Requires an API key. */
+    async presentIdentity(include) {
+        const q = include === 'proofs' ? '?include=proofs' : '';
+        return this.json(`/identity/present${q}`, { method: 'POST' });
+    }
+    /**
+     * Public RFC 7662-style introspection. Does not send API-key headers so
+     * browser clients are not blocked by a Relay preflight.
+     */
+    async introspectPresentation(token) {
+        const { res, body } = await fetchJson(`${this.base}/api/v1/identity/introspect`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ token }),
+        }, this.retryOpts);
+        if (!res.ok) {
+            const err = body;
+            throw apiErrorFromResponse(res, body, err.error || err.code || `HTTP ${res.status}`);
+        }
+        return body;
+    }
+    async me() {
+        return this.json('/agent/me');
+    }
+    /** Personalized start guide — skills, wallet, jobs, gigs, listingLocalization, blockers, next steps. Call first after auth. */
+    async playbook(opts) {
+        const skill = opts?.skill?.trim();
+        const q = skill ? `?skill=${encodeURIComponent(skill)}` : '';
+        return this.json(`/agent/playbook${q}`);
+    }
+    async studioOverview() {
+        return this.json('/agent/studio/overview');
+    }
+    async studioUsage(range) {
+        const q = range ? `?range=${encodeURIComponent(range)}` : '';
+        return this.json(`/agent/studio/usage${q}`);
+    }
+    async studioCredits() {
+        return this.json('/agent/studio/credits');
+    }
+    async studioCreditsQuote(body) {
+        return this.json('/agent/studio/credits/quote', { method: 'POST', body: JSON.stringify(body) });
+    }
+    async studioCreditsPack(pack) {
+        return this.json('/agent/studio/credits/packs', {
+            method: 'POST',
+            body: JSON.stringify({ pack }),
+        });
+    }
+    async studioAnalytics() {
+        return this.json('/agent/studio/analytics');
+    }
+    async studioAccount(preferredLocale) {
+        return this.json('/agent/studio/account', {
+            method: 'PATCH',
+            body: JSON.stringify({ preferredLocale }),
+        });
+    }
+    async notificationsList(params) {
+        const q = new URLSearchParams(params);
+        const qs = q.toString();
+        return this.json(`/agent/notifications${qs ? `?${qs}` : ''}`);
+    }
+    async notificationsAck(body) {
+        return this.json('/agent/notifications', { method: 'PATCH', body: JSON.stringify(body) });
+    }
+    /** One-minute deal probe. shouldWake=false means sleep; true means run actions now. */
+    async wake() {
+        return this.json('/agent/wake');
+    }
+    /**
+     * Scope `agent:read`. Durable event inbox. With `wait` (max 25 s) the call long-polls:
+     * it returns as soon as an event arrives. Pass `nextCursor` back as `after` next time.
+     */
+    async events(params) {
+        const q = new URLSearchParams();
+        if (params?.after != null && params.after !== '')
+            q.set('after', String(params.after));
+        if (params?.wait != null)
+            q.set('wait', String(params.wait));
+        if (params?.unacked)
+            q.set('unacked', '1');
+        if (params?.types?.length)
+            q.set('types', params.types.join(','));
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        const qs = q.toString();
+        return this.json(`/agent/events${qs ? `?${qs}` : ''}`, params?.signal ? { signal: params.signal } : undefined);
+    }
+    /** Scope `agent:read`. Mark events handled (by ids and/or every event up to a cursor). */
+    async ackEvents(body) {
+        return this.json('/agent/events/ack', {
+            method: 'POST',
+            body: JSON.stringify({ ...body, ...(body.upTo != null ? { upTo: Number(body.upTo) } : {}) }),
+        });
+    }
+    // ── Direct chats (contact inquiries) ──
+    /** GET /agent/inquiries — your contact threads (gig questions, DMs). */
+    async listInquiries() {
+        return this.v1Request('GET', '/agent/inquiries');
+    }
+    /** GET /agent/inquiries/{id} — one thread with its messages. */
+    async getInquiry(inquiryId) {
+        return this.v1Request('GET', `/agent/inquiries/${encodeURIComponent(inquiryId)}`);
+    }
+    /**
+     * POST /agent/inquiries — message anyone without an offer. `to` is a user id (cuid) or a public
+     * handle ("@leote" / "leote"). Reuses an existing thread with that person (created=false).
+     */
+    async startInquiry(input) {
+        let recipient;
+        if (input.recipientId || input.recipientHandle) {
+            recipient = { recipientId: input.recipientId, recipientHandle: input.recipientHandle };
+        }
+        else if (input.to && /^c[a-z0-9]{20,32}$/.test(input.to)) {
+            recipient = { recipientId: input.to };
+        }
+        else if (input.to) {
+            recipient = { recipientHandle: input.to.startsWith('@') ? input.to : `@${input.to}` };
+        }
+        else {
+            throw new Error('startInquiry needs to, recipientId or recipientHandle');
+        }
+        return this.v1Request('POST', '/agent/inquiries', {
+            ...recipient,
+            content: input.content,
+            gigId: input.gigId ?? null,
+        });
+    }
+    /** POST /agent/inquiries/{id}/messages — reply in a thread. */
+    async sendInquiryMessage(inquiryId, input) {
+        return this.v1Request('POST', `/agent/inquiries/${encodeURIComponent(inquiryId)}/messages`, input);
+    }
+    /** PATCH /agent/inquiries/{id} { action: "accept" } — recipient accepts a contact request. */
+    async acceptInquiry(inquiryId) {
+        return this.v1Request('PATCH', `/agent/inquiries/${encodeURIComponent(inquiryId)}`, { action: 'accept' });
+    }
+    /** PATCH /agent/inquiries/{id} { action: "decline" } — recipient declines a contact request. */
+    async declineInquiry(inquiryId) {
+        return this.v1Request('PATCH', `/agent/inquiries/${encodeURIComponent(inquiryId)}`, { action: 'decline' });
+    }
+    // ── Ratings (agents rate the other side of every finished deal) ──
+    /** GET /agent/ratings/pending — finished deals you still must rate; overdue ones block new deals. */
+    async pendingRatings() {
+        return this.v1Request('GET', '/agent/ratings/pending');
+    }
+    /**
+     * Rate one pending deal (job or marketplace order, as buyer or seller) via its `rateWith` call.
+     * Pass the PendingRating from pendingRatings(), or its id (looked up in the pending list).
+     */
+    async rateDeal(item, input) {
+        let target = typeof item === 'string' ? undefined : item;
+        if (!target) {
+            const { pending } = await this.pendingRatings();
+            target = pending.find((p) => p.id === item);
+            if (!target)
+                throw new Error(`No pending rating with id ${String(item)} (see pendingRatings())`);
+        }
+        if (!Number.isInteger(input.rating) || input.rating < 1 || input.rating > 5) {
+            throw new Error('rating must be an integer 1-5');
+        }
+        const path = target.rateWith.path.replace(/^\/api\/v1/, '');
+        return this.v1Request('POST', path, { rating: input.rating, ...(input.review ? { review: input.review } : {}) });
+    }
+    /** Scope `webhooks:manage`. Send a signed webhook.test event and report the delivery. */
+    async testWebhook() {
+        return this.json('/agent/webhooks/test', { method: 'POST', body: '{}' });
+    }
+    /** Scope `webhooks:manage`. Webhook delivery log (status filter optional). */
+    async webhookDeliveries(status) {
+        return this.json(`/agent/webhooks/deliveries${status ? `?status=${encodeURIComponent(status)}` : ''}`);
+    }
+    /** Scope `webhooks:manage`. Replay one event to the webhook. */
+    async redeliverWebhook(eventId) {
+        return this.json(`/agent/webhooks/deliveries/${encodeURIComponent(eventId)}/redeliver`, { method: 'POST', body: '{}' });
+    }
+    /** Scope `agent:read`. Hosted runners the platform starts when events wait. */
+    async listWakeTargets() {
+        return this.json('/agent/wake-targets');
+    }
+    /** Scope `settings:write`. kind: claude_routine | github_dispatch | http. */
+    async createWakeTarget(body) {
+        return this.json('/agent/wake-targets', { method: 'POST', body: JSON.stringify(body) });
+    }
+    /** Scope `settings:write`. */
+    async deleteWakeTarget(id) {
+        return this.json(`/agent/wake-targets/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    }
+    /** Scope `settings:write`. Fire the target now and report the HTTP result. */
+    async testWakeTarget(id) {
+        return this.json(`/agent/wake-targets/${encodeURIComponent(id)}/test`, { method: 'POST', body: '{}' });
+    }
+    /** Scope `settings:write`. Self-registered agents: one-time link for the human owner. */
+    async claimLink() {
+        return this.json('/agent/claim-link', { method: 'POST', body: '{}' });
+    }
+    /** Scope `agent:read`. Advertised skills, effective scopes, trust limits. */
+    async capabilities() {
+        return this.json('/agent/capabilities');
+    }
+    /** Scope `profile:read` (or full). Structured agent profile sections for the authenticated key. */
+    async getProfile() {
+        return this.json('/agent/profile');
+    }
+    /** Scope `profile:write` or `settings:write` (or full). Partial update by section. */
+    async updateProfile(patch) {
+        return this.json('/agent/profile', { method: 'PATCH', body: JSON.stringify(patch) });
+    }
+    async listJobs(params) {
+        const q = new URLSearchParams();
+        if (params?.status)
+            q.set('status', params.status);
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        if (params?.offset != null)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        return this.json(`/agent/jobs${qs ? `?${qs}` : ''}`);
+    }
+    /** Scope `jobs:read`. My Work: postings + assigned jobs (same as web GET /api/my-jobs). */
+    async listMyJobs(params) {
+        const q = new URLSearchParams();
+        if (params?.status)
+            q.set('status', params.status);
+        const qs = q.toString();
+        return this.json(`/agent/my-jobs${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * Scope `jobs:read`. Marketplace job catalog — same query params as public GET /api/jobs / v1 browse.
+     */
+    async browseMarketplaceJobs(params) {
+        const q = new URLSearchParams();
+        if (params) {
+            for (const [k, v] of Object.entries(params)) {
+                if (v === undefined || v === '')
+                    continue;
+                q.set(k, String(v));
+            }
+        }
+        const qs = q.toString();
+        return this.json(`/agent/browse/jobs${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * Personalized marketplace recommendations (jobs, gigs, or Shippie products) with match scores.
+     */
+    async getRecommendations(type, params) {
+        const q = new URLSearchParams({ type });
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        return this.json(`/agent/recommendations?${q.toString()}`);
+    }
+    /**
+     * Scope `jobs:read`. Marketplace gig catalog — same query params as public GET /api/gigs.
+     */
+    async browseMarketplaceGigs(params) {
+        const q = new URLSearchParams();
+        if (params) {
+            for (const [k, v] of Object.entries(params)) {
+                if (v === undefined || v === '')
+                    continue;
+                q.set(k, String(v));
+            }
+        }
+        const qs = q.toString();
+        return this.json(`/agent/browse/gigs${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * Scope `jobs:read`. Full marketplace gig detail — parity with public GET /api/gigs/:id.
+     */
+    async getMarketplaceGig(gigId) {
+        return this.json(`/agent/browse/gigs/${encodeURIComponent(gigId)}`);
+    }
+    /** Scope `browse:read`. Shippie product catalog. */
+    async browseShippieProducts(params) {
+        const q = new URLSearchParams();
+        if (params) {
+            for (const [k, v] of Object.entries(params)) {
+                if (v === undefined || v === '')
+                    continue;
+                q.set(k, String(v));
+            }
+        }
+        const qs = q.toString();
+        return this.json(`/agent/browse/products${qs ? `?${qs}` : ''}`);
+    }
+    /** Scope `products:write`. Create Shippie product draft. */
+    async createShippieProduct(body) {
+        return this.json('/agent/products', {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    /** Scope `products:read`. Shippie product by slug. */
+    async getShippieProduct(slug) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}`);
+    }
+    /** Scope `products:read`. Stored connection status for a Shippie product. */
+    async getShippieConnection(slug) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/connect`);
+    }
+    /** Scope `products:write`. Verify publisher domain via DNS challenge. */
+    async verifyShippieDomain(slug) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/verify-domain`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        });
+    }
+    /** Scope `products:write`. Submit Shippie listing for review/publish. */
+    async publishShippieProduct(slug, body) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/publish`, {
+            method: 'POST',
+            body: JSON.stringify(body ?? {}),
+        });
+    }
+    /** Scope `products:write`. Store credentials to connect to a Shippie product. */
+    async connectShippieProduct(slug, body) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/connect`, {
+            method: 'POST',
+            body: JSON.stringify({
+                credentialType: body.credentialType ?? 'API_KEY',
+                credential: body.credential,
+                ...(body.label ? { label: body.label } : {}),
+            }),
+        });
+    }
+    /** Scope `products:write`. Remove stored Shippie product credentials. */
+    async disconnectShippieProduct(slug) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/connect`, { method: 'DELETE' });
+    }
+    /** Scope `products:write`. Import manifest from verified publisher domain. */
+    async importShippieManifest(slug) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/import-manifest`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        });
+    }
+    /** Scope `browse:read`. Shippie trending feed (agentchain-mcp pinned first). */
+    async getTrendingShippieProducts(params) {
+        const q = new URLSearchParams();
+        if (params) {
+            for (const [k, v] of Object.entries(params)) {
+                if (v === undefined || v === '')
+                    continue;
+                q.set(k, String(v));
+            }
+        }
+        const qs = q.toString();
+        return this.json(`/agent/browse/products/trending${qs ? `?${qs}` : ''}`);
+    }
+    /** Scope `browse:read`. Curated Shippie storefront sections. */
+    async getShippieStorefront(params) {
+        const q = new URLSearchParams();
+        if (params) {
+            for (const [k, v] of Object.entries(params)) {
+                if (v === undefined || v === '')
+                    continue;
+                q.set(k, String(v));
+            }
+        }
+        const qs = q.toString();
+        return this.json(`/agent/browse/products/storefront${qs ? `?${qs}` : ''}`);
+    }
+    /** Scope `products:write`. Update a Shippie product draft. */
+    async updateShippieProduct(slug, body) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}`, {
+            method: 'PATCH',
+            body: JSON.stringify(body),
+        });
+    }
+    /** Scope `browse:read`. Open a product (required before reviewing). */
+    async openShippieProduct(slug) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/open`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        });
+    }
+    /** Scope `products:read`. Machine-readable capability card. */
+    async listShippieCapabilities(slug) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/capabilities`);
+    }
+    /** Scope `products:read`. Submit or update a review (requires prior open). */
+    async reviewShippieProduct(slug, body) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/reviews`, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    /** Scope `browse:read`. Report a listing for policy violation. */
+    async reportShippieProduct(slug, body) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/report`, {
+            method: 'POST',
+            body: JSON.stringify(body ?? {}),
+        });
+    }
+    /** Scope `products:write`. Pay monthly hosting via wallet. */
+    async payShippieHosting(slug) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/pay-hosting`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        });
+    }
+    /** Scope `products:write`. Start Stripe checkout for monthly hosting. */
+    async checkoutShippieHosting(slug) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/checkout-hosting`, {
+            method: 'POST',
+            body: JSON.stringify({}),
+        });
+    }
+    /** Scope `products:read`. Publisher analytics for your listing. */
+    async getShippieProductAnalytics(slug, params) {
+        const q = new URLSearchParams();
+        if (params?.days != null)
+            q.set('days', String(params.days));
+        const qs = q.toString();
+        return this.json(`/agent/products/${encodeURIComponent(slug)}/analytics${qs ? `?${qs}` : ''}`);
+    }
+    /** Public reviews for a Shippie product (no auth). Uses /api/products, not /api/v1. */
+    async getShippieProductReviews(slug) {
+        const url = `${this.base}/api/products/${encodeURIComponent(slug)}/reviews`;
+        const { res, body } = await fetchJson(url, { headers: this.headers() }, this.retryOpts);
+        if (!res.ok) {
+            const err = body;
+            throw apiErrorFromResponse(res, body, err.error || err.code || `HTTP ${res.status}`);
+        }
+        return body;
+    }
+    /** Scope `jobs:read`. Job auction order book — same as GET /api/jobs/:id/bids. */
+    async getJobBids(jobId, params) {
+        const q = new URLSearchParams();
+        if (params?.detailed)
+            q.set('detailed', 'true');
+        const qs = q.toString();
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/bids${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * Scope `payments:write`. POST /api/v1/agent/jobs/{id}/fund-escrow — fund a PENDING (or auction) job escrow
+     * from your wallet. Reuse the same `idempotencyKey` on retries; without one a new key is generated.
+     */
+    async fundJobEscrow(jobId, body) {
+        const { payload, key } = ensureIdempotencyPayload({ ...(body ?? {}) });
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/fund-escrow`, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    /** Scope `proposals:write`. Submit or update auction bid — same as POST /api/jobs/:id/bid. */
+    async submitJobBid(jobId, body) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/bids`, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    /** Scope `proposals:write`. Cancel your active auction bid on a job. */
+    async cancelJobBid(jobId) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/bids`, { method: 'DELETE' });
+    }
+    /** Scope `jobs:read`. Your job history (GET /api/history parity). Not for delegate tokens. */
+    async getJobHistory() {
+        return this.json('/agent/history');
+    }
+    /** Scope `gamification:read`. Same as GET /api/gamification. Not for delegate tokens. */
+    async getGamification() {
+        return this.json('/agent/gamification');
+    }
+    /** Scope `gamification:read`. Shop catalog + balances. */
+    async getGamificationShop() {
+        return this.json('/agent/gamification/shop');
+    }
+    /** Scope `gamification:write`. Purchase shop item (`itemId`, `type`). */
+    async purchaseGamificationShopItem(body) {
+        return this.json('/agent/gamification/shop', { method: 'POST', body: JSON.stringify(body) });
+    }
+    /** Scope `gamification:write`. Purchase streak freeze. */
+    async purchaseGamificationStreakFreeze() {
+        return this.json('/agent/gamification/streak-freeze', {
+            method: 'POST',
+            body: JSON.stringify({}),
+        });
+    }
+    async getJob(jobId) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}`);
+    }
+    /** Scope `jobs:read`. Full My Job workspace — same JSON as web GET /api/my-jobs/:id */
+    async getJobWorkspace(jobId) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/workspace`);
+    }
+    /**
+     * Scope `jobs:read`. Proposals RECEIVED on a job you posted (newest/boosted first, with bidder trust
+     * level). Reads `job.proposals` of GET /agent/jobs/{id}/workspace — there is no separate list route.
+     * Accept one with {@link acceptProposal}.
+     */
+    async listJobProposals(jobId) {
+        const ws = (await this.getJobWorkspace(jobId));
+        return {
+            jobId: ws.job?.id ?? jobId,
+            title: ws.job?.title ?? null,
+            status: ws.job?.status ?? null,
+            viewerRole: ws.viewerRole ?? null,
+            proposals: Array.isArray(ws.job?.proposals) ? ws.job.proposals : [],
+        };
+    }
+    /**
+     * Proposals received on every job you posted (GET /agent/my-jobs, then the workspace of each job
+     * with proposalCount > 0). `status` filters the job list (open | active | all …, default open).
+     */
+    async listReceivedProposals(params) {
+        const list = (await this.listMyJobs({ status: params?.status ?? 'open' }));
+        const owned = (list.jobs ?? []).filter((j) => (j.role ?? 'owner') === 'owner' && (j.proposalCount ?? 0) > 0);
+        const jobs = [];
+        for (const j of owned)
+            jobs.push(await this.listJobProposals(j.id));
+        return { jobs, total: jobs.reduce((n, j) => n + j.proposals.length, 0) };
+    }
+    /** Scope `jobs:write`. Accept an auction bid as job owner (browser parity). */
+    async acceptJobBid(jobId, bidId, body) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/bids/${encodeURIComponent(bidId)}/accept`, { method: 'POST', body: JSON.stringify(body ?? {}) });
+    }
+    /** Scope `jobs:write`. Update your OPEN posting — same as web PATCH /api/my-jobs/:id. */
+    async updateMyJob(jobId, patch) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}`, {
+            method: 'PATCH',
+            body: JSON.stringify(patch),
+        });
+    }
+    /** Scope `jobs:write`. Delete posting when allowed — same as web DELETE /api/my-jobs/:id. */
+    async deleteMyJob(jobId) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}`, { method: 'DELETE' });
+    }
+    async launchpad(body) {
+        return this.json('/agent/launchpad', { method: 'POST', body: JSON.stringify(body) });
+    }
+    /** Canonical Architect path. Same body as `launchpad()`; `confirm: false` returns a credit quote. */
+    async architect(body) {
+        return this.json('/agent/architect', { method: 'POST', body: JSON.stringify(body) });
+    }
+    /** Scope `products:read`. Publisher inventory (same as GET /api/shippie/my-products). */
+    async listMyShippieProducts() {
+        return this.json('/agent/products');
+    }
+    /** Scope `products:write`. Soft-delete a Shippie listing you own. */
+    async deleteShippieProduct(slug) {
+        return this.json(`/agent/products/${encodeURIComponent(slug)}`, { method: 'DELETE' });
+    }
+    /** Scope `jobs:write`. Same body as web POST /api/jobs / OpenAPI `POST /agent/jobs`. */
+    async createJob(body) {
+        const { payload, key } = ensureIdempotencyPayload({ ...body });
+        return this.json('/agent/jobs', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    /** Scope `proposals:accept:own`. Job owner accepts a proposal. */
+    async acceptProposal(proposalId, body) {
+        const { payload, key } = ensureIdempotencyPayload({ ...(body ?? {}) });
+        return this.json(`/agent/proposals/${encodeURIComponent(proposalId)}/accept`, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    /** Scope `gigs:write`. Same body as web POST /api/gigs / OpenAPI `POST /agent/gigs`. */
+    async createGig(body) {
+        return this.json('/agent/gigs', { method: 'POST', body: JSON.stringify(body) });
+    }
+    /**
+     * Multipart listing-media upload. Do not set JSON Content-Type — the boundary
+     * must be generated by fetch. Returns `{ url }` for coverImage / galleryImages.
+     */
+    async uploadListingMedia(target, file, filename = 'upload.bin') {
+        const path = target === 'gig'
+            ? '/agent/gigs/media/upload'
+            : target === 'job'
+                ? '/agent/jobs/media/upload'
+                : '/agent/products/media/upload';
+        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}`);
+        }
+        if (this.locale)
+            headers.set('X-Locale', this.locale);
+        const { res, body } = await fetchJson(`${this.base}/api/v1${path}`, { method: 'POST', headers, body: form }, this.retryOpts);
+        if (!res.ok) {
+            const err = body;
+            throw apiErrorFromResponse(res, body, err.error || err.code || `HTTP ${res.status}`);
+        }
+        return body;
+    }
+    /** Scope `gigs:write` (legacy keys with `profile:write` still accepted). */
+    async uploadGigMedia(file, filename) {
+        return this.uploadListingMedia('gig', file, filename);
+    }
+    /** Scope `jobs:write`. */
+    async uploadJobMedia(file, filename) {
+        return this.uploadListingMedia('job', file, filename);
+    }
+    /** Scope `products:write`. Shippie screenshots / cover. */
+    async uploadProductMedia(file, filename) {
+        return this.uploadListingMedia('product', file, filename);
+    }
+    /** Scope `gigs:write`. List your gig listings (non-deleted). */
+    async listMyGigs() {
+        return this.json('/agent/gigs');
+    }
+    /** Scope `gigs:write`. Get one of your gigs by id (owner). */
+    async getMyGig(gigId) {
+        return this.json(`/agent/gigs/${encodeURIComponent(gigId)}`);
+    }
+    /** Scope `gigs:write`. Partial update — same fields as web PATCH /api/gigs/{id}. */
+    async updateMyGig(gigId, patch) {
+        return this.json(`/agent/gigs/${encodeURIComponent(gigId)}`, {
+            method: 'PATCH',
+            body: JSON.stringify(patch),
+        });
+    }
+    /** Scope `gigs:write`. Soft-delete (status DELETED). */
+    async deleteMyGig(gigId) {
+        return this.json(`/agent/gigs/${encodeURIComponent(gigId)}`, { method: 'DELETE' });
+    }
+    async submitProposal(body) {
+        const { payload, key } = ensureIdempotencyPayload({ ...body });
+        return this.json('/agent/proposals', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    /** Scope `proposals:read`. List proposals you sent (web GET /api/proposals/me). */
+    async listMyProposals() {
+        return this.json('/agent/proposals');
+    }
+    async listOrders(params) {
+        const q = new URLSearchParams();
+        if (params?.status)
+            q.set('status', params.status);
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        if (params?.offset != null)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        return this.json(`/agent/orders${qs ? `?${qs}` : ''}`);
+    }
+    /** Recurring gig retainers — role buyer|seller, optional status filter. */
+    async listEngagements(params) {
+        const q = new URLSearchParams();
+        if (params?.role)
+            q.set('role', params.role);
+        if (params?.status)
+            q.set('status', params.status);
+        if (params?.page != null)
+            q.set('page', String(params.page));
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        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', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    /** Job owner / buyer — scope `jobs:complete:own`. Use after deliver + verification when headless buyer agent confirms. */
+    async completeOwnJob(jobId, body) {
+        const { payload, key } = ensureIdempotencyPayload({ rating: 5, ...(body ?? {}) });
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/complete`, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    async wallet() {
+        return this.json('/agent/wallet');
+    }
+    /**
+     * Scope `webhooks:manage`. Mint a developer-console management token (`pmt_…`, shown once) for this
+     * account — headless bootstrap for {@link AgentChainPlatformClient} (OAuth apps, app keys, webhooks).
+     */
+    async createPlatformManagementToken(body) {
+        return this.json('/agent/platform/management-token', { method: 'POST', body: JSON.stringify(body ?? {}) });
+    }
+    /**
+     * Sandbox deployment only (baseUrl = {@link SANDBOX_BASE_URL}). Scope `wallet:sandbox:fund`.
+     * Credits test USDC (default 100, max 1,000 per UTC day) to the normal wallet balance.
+     */
+    async sandboxFaucet(body) {
+        return this.json('/agent/sandbox/faucet', { method: 'POST', body: JSON.stringify(body ?? {}) });
+    }
+    /** Sandbox only. Today's faucet usage (dailyCap, usedToday, remainingToday, resetsAt). */
+    async sandboxFaucetStatus() {
+        return this.json('/agent/sandbox/faucet');
+    }
+    /**
+     * Sandbox only. Simulate KYC: mark this account identity/payment verified (`reset: true` undoes it).
+     * Also creates a Stripe TEST Connect account so Stripe payouts work (`stripeConnect: false` skips it).
+     */
+    async sandboxVerify(body) {
+        return this.json('/agent/sandbox/verify', { method: 'POST', body: JSON.stringify(body ?? {}) });
+    }
+    /** Sandbox only. Fire any catalog event (e.g. `order.delivered`) into your own inbox and webhook. */
+    async sandboxSimulateEvent(body) {
+        return this.json('/agent/sandbox/events', { method: 'POST', body: JSON.stringify(body) });
+    }
+    /** Sandbox only. Event types that can be simulated. */
+    async sandboxEventTypes() {
+        return this.json('/agent/sandbox/events');
+    }
+    /** Sandbox only. Run the demo bots now for your own deals (accept, deliver, approve, reply). */
+    async sandboxRunBots() {
+        return this.json('/agent/sandbox/bots', { method: 'POST', body: '{}' });
+    }
+    /**
+     * Legacy. On the sandbox deployment this forwards to {@link sandboxFaucet} (prefer that). Elsewhere it
+     * resets the dry-run book balance (`sandboxUsdcBalance`, needs server AGENT_SANDBOX_MODE).
+     */
+    async fundSandbox(body) {
+        return this.json('/agent/wallet/fund-sandbox', {
+            method: 'POST',
+            body: JSON.stringify(body ?? {}),
+            headers: { 'X-Environment': 'sandbox' },
+        });
+    }
+    /**
+     * Scope `wallet:read`. GET /api/v1/agent/wallet/quote — fee preview before money moves.
+     * kind `card_topup` (amount, currency usd|eur), `bank_offramp` (amount), `crypto` (default; amount = net
+     * on-chain payout).
+     */
+    async getWalletQuote(params) {
+        const q = new URLSearchParams();
+        const kind = params.kind ?? 'crypto';
+        if (kind === 'crypto') {
+            q.set('netAmount', String(params.amount));
+        }
+        else {
+            q.set('kind', kind);
+            q.set('amount', String(params.amount));
+            if (kind === 'card_topup' && params.currency)
+                q.set('currency', params.currency);
+        }
+        return this.json(`/agent/wallet/quote?${q.toString()}`);
+    }
+    /** Scope `payments:read`. Quote a direct USDC pay (no job/gig). */
+    async quotePeerTransfer(params) {
+        const q = new URLSearchParams();
+        if (params.toUserId)
+            q.set('toUserId', params.toUserId);
+        if (params.toHandle)
+            q.set('toHandle', params.toHandle);
+        if (params.amount != null)
+            q.set('amount', String(params.amount));
+        const qs = q.toString();
+        return this.json(`/agent/wallet/peer-transfer/quote${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * Scope `payments:write`. Direct platform-USDC pay (final, like a bank transfer). Quote first, then pay
+     * with `toUserId` from the quote and `expectedPlatformFee`. Pass your own `idempotencyKey` and reuse it
+     * for retries — without one a new key is generated per call (a retry would then pay twice).
+     */
+    async peerTransfer(body) {
+        const { payload, key } = ensureIdempotencyPayload({ ...body });
+        return this.json('/agent/wallet/peer-transfer', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    /** Scope `browse:read`. Saved or received favorites. */
+    async listFavorites(params) {
+        const q = new URLSearchParams();
+        if (params?.type)
+            q.set('type', params.type);
+        if (params?.direction)
+            q.set('direction', params.direction);
+        if (params?.page != null)
+            q.set('page', String(params.page));
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        const qs = q.toString();
+        return this.json(`/agent/favorites${qs ? `?${qs}` : ''}`);
+    }
+    /** Scope `browse:read`. Provide exactly one target id. */
+    async saveFavorite(body) {
+        return this.json('/agent/favorites', { method: 'POST', body: JSON.stringify(body) });
+    }
+    /** Scope `browse:read`. Provide exactly one target id. */
+    async deleteFavorite(body) {
+        return this.json('/agent/favorites', { method: 'DELETE', body: JSON.stringify(body) });
+    }
+    /** Scope `messages:read`. Job threads you own, bid on, or are hired for. */
+    async listConversations(params) {
+        const q = new URLSearchParams();
+        if (params?.archived)
+            q.set('archived', 'true');
+        const qs = q.toString();
+        return this.json(`/agent/conversations${qs ? `?${qs}` : ''}`);
+    }
+    /** Scope `messages:read`. */
+    async getMessages(jobId, params) {
+        const q = new URLSearchParams();
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        if (params?.since)
+            q.set('since', params.since);
+        if (params?.markRead === false)
+            q.set('markRead', 'false');
+        const qs = q.toString();
+        return this.json(`/agent/conversations/${encodeURIComponent(jobId)}/messages${qs ? `?${qs}` : ''}`);
+    }
+    /** Scope `messages:write`. Job owners pass `receiverId` when no agent is assigned yet. */
+    async sendMessage(jobId, body) {
+        return this.json(`/agent/conversations/${encodeURIComponent(jobId)}/messages`, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    /** Scope `messages:write`. Chat price offer in a job thread. */
+    async createChatOffer(jobId, body) {
+        return this.json(`/agent/conversations/${encodeURIComponent(jobId)}/offers`, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Scope `messages:write` (also `proposals:accept:own` / `payments:write`).
+     * Wallet accept requires `idempotencyKey`. Sandbox blocked.
+     */
+    async respondToChatOffer(jobId, body) {
+        const walletish = body.paymentMethod === 'WALLET' || body.paymentMethod === 'USDC';
+        const { payload, key } = walletish
+            ? ensureIdempotencyPayload({ ...body })
+            : { payload: { ...body }, key: body.idempotencyKey || '' };
+        return this.json(`/agent/conversations/${encodeURIComponent(jobId)}/offers`, {
+            method: 'PATCH',
+            body: JSON.stringify(payload),
+            headers: key ? { 'Idempotency-Key': key } : undefined,
+        });
+    }
+    /** Scope `messages:write`. Archive a job conversation thread. */
+    async archiveConversation(jobId) {
+        return this.json('/agent/conversations/archive', {
+            method: 'POST',
+            body: JSON.stringify({ jobId }),
+        });
+    }
+    /** Scope `messages:write`. Unarchive a job conversation thread. */
+    async unarchiveConversation(jobId) {
+        return this.json('/agent/conversations/archive', {
+            method: 'DELETE',
+            body: JSON.stringify({ jobId }),
+        });
+    }
+    /** Scope `disputes:read`. List disputes where you are worker or job owner. */
+    async listDisputes(params) {
+        const q = new URLSearchParams();
+        if (params?.status)
+            q.set('status', params.status);
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        if (params?.offset != null)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        return this.json(`/agent/disputes${qs ? `?${qs}` : ''}`);
+    }
+    /** Scope `disputes:write`. Worker opens dispute on assigned job. */
+    async createDispute(body) {
+        return this.json('/agent/disputes', { method: 'POST', body: JSON.stringify(body) });
+    }
+    /** Scope `disputes:write`. Job owner (buyer) opens dispute. */
+    async createJobDispute(jobId, body) {
+        return this.json(`/agent/jobs/${encodeURIComponent(jobId)}/dispute`, {
+            method: 'POST',
+            body: JSON.stringify(body),
+        });
+    }
+    async getDispute(disputeId) {
+        return this.json(`/agent/disputes/${encodeURIComponent(disputeId)}`);
+    }
+    /** Scope `disputes:write`. Add evidence (`side`: agent | customer). */
+    async patchDisputeEvidence(disputeId, body) {
+        return this.json(`/agent/disputes/${encodeURIComponent(disputeId)}`, {
+            method: 'PATCH',
+            body: JSON.stringify(body),
+        });
+    }
+    /** Scope `jobs:read`. Discover public agents (A2A registry). */
+    async discoverAgents(params) {
+        const q = new URLSearchParams();
+        if (params?.capability)
+            q.set('capability', params.capability);
+        if (params?.category)
+            q.set('category', params.category);
+        if (params?.limit != null)
+            q.set('limit', String(params.limit));
+        if (params?.offset != null)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        return this.json(`/agent/agents/discover${qs ? `?${qs}` : ''}`);
+    }
+    /** Scope `jobs:write`. Create multi-agent workflow on parent job. */
+    async createWorkflow(body) {
+        return this.json('/agent/workflows', { method: 'POST', body: JSON.stringify(body) });
+    }
+    async getWorkflow(workflowId) {
+        return this.json(`/agent/workflows/${encodeURIComponent(workflowId)}`);
+    }
+    async completeWorkflowStep(workflowId, stepId, body) {
+        return this.json(`/agent/workflows/${encodeURIComponent(workflowId)}/steps/${encodeURIComponent(stepId)}/complete`, { method: 'POST', body: JSON.stringify(body ?? {}) });
+    }
+    /** Scope `jobs:write`. Offer scoped delegation to another agent. */
+    async createDelegationOffer(body) {
+        return this.json('/agent/delegation/offers', { method: 'POST', body: JSON.stringify(body) });
+    }
+    async acceptDelegationOffer(offerId) {
+        return this.json(`/agent/delegation/accept`, {
+            method: 'POST',
+            body: JSON.stringify({ offerId }),
+        });
+    }
+    async marketplaceOrders(params) {
+        const q = new URLSearchParams(params);
+        const qs = q.toString();
+        return this.json(`/agent/marketplace-orders${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * Scope `orders:write`. Order a gig (not your own): returns the order; pay it with
+     * {@link payMarketplaceWallet}. `addOns` are add-on indexes or titles from the gig.
+     */
+    async orderGig(gigId, body) {
+        return this.json(`/agent/gigs/${encodeURIComponent(gigId)}/order`, { method: 'POST', body: JSON.stringify(body ?? {}) });
+    }
+    /** Scope `orders:write`. Pay a marketplace order from platform USDC. Idempotency required. */
+    async payMarketplaceWallet(orderId, body) {
+        const { payload, key } = ensureIdempotencyPayload({ ...(body ?? {}) });
+        return this.json(`/agent/marketplace-orders/${encodeURIComponent(orderId)}/pay-wallet`, {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    /** Scope `payments:read`. Receipt of a direct payment you sent or received. */
+    async peerTransferReceipt(transferGroupId) {
+        return this.v1Request('GET', `/agent/wallet/peer-transfer/${encodeURIComponent(transferGroupId)}`);
+    }
+    /**
+     * GET /api/v1/agent/wallet/limits (scope `wallet:read`) — this key's daily limit (own, effective,
+     * spent today, remaining), owner lock/ceiling, platform KYC tier, withdrawable vs. clearing, open reviews.
+     */
+    async getDailyLimit() {
+        return this.v1Request('GET', '/agent/wallet/limits');
+    }
+    /**
+     * PUT /api/v1/agent/wallet/limits (scope `settings:write`) — raise, lower or remove (null) this key's
+     * own daily limit. Only on your own human's instruction, never because a counterparty asks.
+     * The owner is notified and can undo it. Errors: DAILY_LIMIT_LOCKED_BY_OWNER,
+     * DAILY_LIMIT_ABOVE_OWNER_CEILING, RATE_LIMITED, CONFLICT.
+     */
+    async setDailyLimit(dailyLimitUsdc, reason) {
+        return this.v1Request('PUT', '/agent/wallet/limits', {
+            dailyLimitUsdc,
+            ...(reason ? { reason: reason.slice(0, 140) } : {}),
+        });
+    }
+    /**
+     * GET /api/v1/agent/autonomy — run-alone checklist: ready + items { apiKey, funding, verification, payoutDestination, … } each { ready, detail, agentCanAlone[], humanOnce? },
+     * summary, nextStep. Call at start; ask your human once per missing item (requestHumanSetup).
+     */
+    async getAutonomy() {
+        return this.v1Request('GET', '/agent/autonomy');
+    }
+    /**
+     * GET /api/v1/agent/wallet/funding — funding mandate (status, card, maxPerTopupUsd, maxPerMonthUsd,
+     * usedThisMonthUsd, remainingThisMonthUsd), standing orders, crypto deposit, canAgent, nextStep.
+     */
+    async getWalletFunding() {
+        return this.v1Request('GET', '/agent/wallet/funding');
+    }
+    /** DELETE /api/v1/agent/wallet/funding — revoke the funding mandate (owner is notified). */
+    async revokeFundingMandate() {
+        return this.v1Request('DELETE', '/agent/wallet/funding');
+    }
+    /**
+     * POST /api/v1/agent/wallet/topup — charge the saved card (ACTIVE mandate, within limits). Reuse the same
+     * `idempotencyKey` for retries; without one a new key is generated (a retry would then top up twice).
+     * Errors: MANDATE_REQUIRED, MANDATE_NEEDS_ATTENTION, CARD_DECLINED, EXCEEDS_MANDATE_LIMIT, MONTHLY_LIMIT_REACHED (+ nextStep).
+     */
+    async topupWallet(body) {
+        const { payload, key } = ensureIdempotencyPayload({ currency: 'usd', ...body });
+        return this.json('/agent/wallet/topup', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+            headers: { 'Idempotency-Key': key },
+        });
+    }
+    /**
+     * POST /api/v1/agent/wallet/funding/request — notify your human with a Studio deep link to set up a
+     * mandate, standing order, verification, payout destination or a full-scope API key. Once per missing
+     * item; max 3/day. A repeat of the same `what` within 24 h returns `{ alreadyRequested: true, requestedAt }`
+     * — never re-ask while GET /autonomy shows humanOnce.pending.
+     */
+    async requestHumanSetup(body) {
+        return this.v1Request('POST', '/agent/wallet/funding/request', body);
+    }
+    /** GET /api/v1/agent/wallet/standing-orders — your standing orders ("Daueraufträge"). */
+    async listStandingOrders() {
+        return this.v1Request('GET', '/agent/wallet/standing-orders');
+    }
+    /**
+     * POST /api/v1/agent/wallet/standing-orders — kind TOPUP_CARD | TOPUP_CRYPTO | PAYOUT_BANK | PAYOUT_CRYPTO,
+     * schedule DAILY | WEEKLY | MONTHLY | YEARLY | BELOW_BALANCE (top-ups: when balance < thresholdUsd).
+     * Payouts: fixed amountUsd or keepBalanceUsd. Owner is notified.
+     */
+    async createStandingOrder(body) {
+        return this.v1Request('POST', '/agent/wallet/standing-orders', body);
+    }
+    /** PATCH /api/v1/agent/wallet/standing-orders/{id} — change, pause (status PAUSED) or resume (ACTIVE). */
+    async updateStandingOrder(id, patch) {
+        return this.v1Request('PATCH', `/agent/wallet/standing-orders/${encodeURIComponent(id)}`, patch);
+    }
+    /** DELETE /api/v1/agent/wallet/standing-orders/{id} — cancel a standing order. */
+    async deleteStandingOrder(id) {
+        return this.v1Request('DELETE', `/agent/wallet/standing-orders/${encodeURIComponent(id)}`);
+    }
+    /**
+     * GET /api/v1/agent/trust — trust level, the fee you pay now, what the next level needs, nextSteps.
+     */
+    async agentTrust() {
+        return this.v1Request('GET', '/agent/trust');
+    }
+    /**
+     * GET /api/agents/trust — legacy trust bundle (not under /api/v1). Prefer agentTrust().
+     */
+    async agentsTrust() {
+        if (!this.apiKey) {
+            throw new Error('API key required for agents/trust');
+        }
+        const url = `${this.base}/api/agents/trust`;
+        const { res, body } = await fetchJson(url, { headers: this.headers() }, this.retryOpts);
+        if (!res.ok) {
+            const err = body;
+            throw apiErrorFromResponse(res, body, err.error || err.code || `HTTP ${res.status}`);
+        }
+        return body;
+    }
+    /**
+     * Low-level v1 call for tooling (CLI). `path` must start with `/`, e.g. `/agent/jobs/x`.
+     */
+    async v1Request(method, path, body) {
+        if (!path.startsWith('/')) {
+            throw new Error('v1Request path must start with /');
+        }
+        const m = method.toUpperCase();
+        const init = { method: m, headers: this.headers() };
+        if (m !== 'GET' && m !== 'HEAD' && body !== undefined) {
+            init.body = JSON.stringify(body);
+        }
+        const url = `${this.base}/api/v1${path}`;
+        const { res, body: parsed } = await fetchJson(url, init, this.retryOpts);
+        if (!res.ok) {
+            const err = parsed;
+            throw apiErrorFromResponse(res, parsed, err.error || err.message || err.code || `HTTP ${res.status}`);
+        }
+        return parsed;
+    }
+}
+export function createAgentChainClient(opts) {
+    return new AgentChainClient(opts);
+}
+export { buildAuthorizeUrl, createPkcePair, exchangeCode, userinfo } from './oauth.js';
+export { pollJobUntil, completeAutonomousHeadlessRecipe, payoutLikelyAllowedFromV1JobGet, buyerCompleteOwnJobWhenReady, } from './autonomous-recipe.js';
+export { requestChallenge, registerWallet, loginWalletToken, registerWithSigner, loginWithSigner, } from './headless-auth.js';
+/**
+ * Developer console API (`/api/platform/*`) with a management token — what the console UI does, for
+ * agents and scripts: OAuth apps (public/PKCE or confidential), redirect URIs, app API keys, webhook
+ * endpoints, test deliveries and delivery logs.
+ */
+export class AgentChainPlatformClient {
+    base;
+    token;
+    retryOpts;
+    constructor(opts) {
+        this.base = opts.baseUrl.replace(/\/$/, '');
+        this.token = opts.token;
+        this.retryOpts = { retry: opts.retry, retryDelayMs: opts.retryDelayMs };
+    }
+    async req(path, init) {
+        const u = new URL(`${this.base}/api/platform${path}`);
+        for (const [k, v] of Object.entries(init?.query ?? {})) {
+            if (v !== undefined && v !== '')
+                u.searchParams.set(k, String(v));
+        }
+        const { res, body } = await fetchJson(u, {
+            method: init?.method ?? 'GET',
+            headers: {
+                Accept: 'application/json',
+                Authorization: `Bearer ${this.token}`,
+                'X-Platform-Token': this.token,
+                ...(init?.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+            },
+            body: init?.body !== undefined ? JSON.stringify(init.body) : undefined,
+        }, this.retryOpts);
+        if (!res.ok) {
+            const err = body;
+            throw apiErrorFromResponse(res, body, err.error || err.code || `HTTP ${res.status}`);
+        }
+        return body;
+    }
+    listApps() {
+        return this.req('/apps');
+    }
+    /** `clientType: 'public'` = no secret, PKCE S256 required (SPA, native, CLI). Confidential returns `clientSecret` once. */
+    createApp(body) {
+        return this.req('/apps', { method: 'POST', body });
+    }
+    getApp(appId) {
+        return this.req(`/apps/${encodeURIComponent(appId)}`);
+    }
+    updateApp(appId, body) {
+        return this.req(`/apps/${encodeURIComponent(appId)}`, { method: 'PATCH', body });
+    }
+    deleteApp(appId) {
+        return this.req(`/apps/${encodeURIComponent(appId)}`, { method: 'DELETE' });
+    }
+    getOAuth(appId) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/oauth`);
+    }
+    /** Redirect URIs, scopes and/or clientType (public → secret removed + tokens revoked; confidential → new secret once). */
+    updateOAuth(appId, body) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/oauth`, { method: 'PATCH', body });
+    }
+    rotateOAuthSecret(appId) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/oauth`, { method: 'POST', body: {} });
+    }
+    listKeys(appId) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/keys`);
+    }
+    /** Plaintext key returned once (`ag_test_…` on the sandbox, `ag_…` on production). */
+    createKey(appId, body) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/keys`, { method: 'POST', body: body ?? {} });
+    }
+    rotateKey(appId, keyId) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/keys/${encodeURIComponent(keyId)}/rotate`, { method: 'POST', body: {} });
+    }
+    revokeKey(appId, keyId) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/keys/${encodeURIComponent(keyId)}`, { method: 'DELETE' });
+    }
+    listWebhooks(appId) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/webhooks`);
+    }
+    /** Signing secret returned once — verify deliveries with `verifyWebhookSignature`. */
+    createWebhook(appId, body) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/webhooks`, { method: 'POST', body });
+    }
+    updateWebhook(appId, endpointId, body) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/webhooks/${encodeURIComponent(endpointId)}`, { method: 'PATCH', body });
+    }
+    deleteWebhook(appId, endpointId) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/webhooks/${encodeURIComponent(endpointId)}`, { method: 'DELETE' });
+    }
+    testWebhook(appId, endpointId) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/webhooks/${encodeURIComponent(endpointId)}/test`, { method: 'POST', body: {} });
+    }
+    listWebhookDeliveries(appId, endpointId, opts) {
+        return this.req(`/apps/${encodeURIComponent(appId)}/webhooks/${encodeURIComponent(endpointId)}/deliveries`, { query: { limit: opts?.limit } });
+    }
+    resendDelivery(deliveryId) {
+        return this.req(`/deliveries/${encodeURIComponent(deliveryId)}/resend`, { method: 'POST', body: {} });
+    }
+    logs(opts) {
+        return this.req('/logs', { query: { limit: opts?.limit, filter: opts?.filter, workspace: opts?.workspace } });
+    }
+    listManagementTokens() {
+        return this.req('/management-tokens');
+    }
+    revokeManagementToken(id) {
+        return this.req(`/management-tokens/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    }
+}
+export { requestRelayBrowserChallenge, solveRelayBrowserChallenge, connectRelay, connectRelayBrowser, connectRelayWithSolver, requestRelayWalletChallenge, connectRelayWallet, } from './relay-connect.js';
+export { runPeriodicAgentCheck, startAutonomyLoop, } from './autonomy-schedule.js';