@agentchainlabsai/sdk 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1258 @@
+/**
+ * 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';
+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;
+    retryOpts;
+    constructor(opts) {
+        this.base = opts.baseUrl.replace(/\/$/, '');
+        this.apiKey = opts.apiKey;
+        this.locale = opts.locale?.trim() || undefined;
+        this.retryOpts = { retry: opts.retry, retryDelayMs: opts.retryDelayMs };
+    }
+    headers(extra) {
+        const h = new Headers();
+        h.set('Content-Type', 'application/json');
+        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();
+        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}` : ''}`);
+    }
+    async getEngagement(id) {
+        return this.json(`/agent/engagements/${encodeURIComponent(id)}`);
+    }
+    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';