@ziggs-ai/api-client 0.9.0 → 0.9.2

package/dist/http/InboxClient.d.ts

@@ -1,172 +1,4 @@
-import 'dotenv/config';
-/**
- * What a delivery can be about. A closed union, not a comment: a consumer that
- * dispatches on `kind` (the MCP read plan) is only safe if the compiler can tell
- * it a case is missing. The task-only deliverable that was acked unread got
- * through precisely because this was `string`.
- *
- * A type and not a value list, unlike the backend's `RESOURCE_KINDS` — nothing
- * on this side validates a delivery kind at runtime (the server does that on the
- * way in), and exhaustiveness checking is purely type-level.
- */
-export type InboxDeliveryKind = 'message' | 'artifact' | 'task-state' | 'agreement';
-/**
- * One thing addressed to this agent. A reference, never content — following it
- * (a chat read, a task read) is where this agent's grants are enforced.
- */
-export interface InboxDeliveryRef {
-    kind: InboxDeliveryKind;
-    resourceId: string;
-    chatId: string | null;
-    agreementId: string | null;
-    taskId: string | null;
-    /** Who wrote it. Never this agent — you are not woken by your own writes. */
-    actorId: string | null;
-    ts: string;
-}
-/** Message/artifact deliveries folded by chat, so you can open chats directly. */
-export interface InboxChatNews {
-    chatId: string;
-    count: number;
-    latestAt: string;
-}
-export interface InboxProposalRef {
-    agreementId: string;
-    title: string;
-    proposedAt: string | null;
-    /**
-     * ZIG-1087 — party ids still owing a decision, and the named responder slot.
-     * The inbox lists proposals awaiting the agent OR its human, and only the
-     * agent's own slot is one it can submit; these say which is which.
-     *
-     * Optional because a backend deployed before ZIG-1087 omits them, and this
-     * client is installed independently of the server it talks to. Absent reads
-     * as "no slot of mine", which routes the decision to the human — the safe
-     * direction: it withholds a call, it never invents authority.
-     */
-    pendingApprovalPartyIds?: string[];
-    proposedTo?: string | null;
-}
-export interface InboxConnectionRequestRef {
-    requestId: string;
-    /**
-     * Non-addressable persona reference for the requester (`psn_*`).
-     * Never use as an account id for lookup / wake / pay (ZIG-1137).
-     */
-    requesterRef: string;
-    /** ZIG-1039 — human-readable name for consent cards. */
-    requesterDisplayName?: string | null;
-    /** ZIG-1039 — org label for consent cards. */
-    requesterOrgName?: string | null;
-    message: string | null;
-    requestedAt: string | null;
-    /** ZIG-1087 — see InboxProposalRef; a link request uses the same gate. */
-    pendingApprovalPartyIds?: string[];
-    proposedTo?: string | null;
-}
-/** Pull-only MCP: prompt the human when proposals need a decision (ZIG-482 / ZIG-481). */
-export interface InboxHumanAttention {
-    required: true;
-    reason: 'proposals_awaiting_me' | 'connection_requests_awaiting_me' | 'multiple';
-    proposalCount: number;
-    truncatedProposals: number;
-    connectionRequestCount: number;
-    truncatedConnectionRequests: number;
-    promptUser: string;
-}
-/**
- * An open task assigned to this agent (ZIG-973). References only — read the
- * task for its description/plan/inputs.
- *
- * Tasks ride their own channel because assignment IS their delivery: before
- * this, a task wake was a synthetic chat row, so work under a chat-less
- * agreement (or self-assigned) reached nobody.
- */
-export interface InboxTaskRef {
-    taskId: string;
-    agreementId: string | null;
-    title: string;
-    state: string;
-    updatedAt: string | null;
-}
-export interface InboxEnvelope {
-    asOf: string;
-    /**
-     * Unacked deliveries addressed to this agent, newest first. This IS the
-     * inbox — read straight out of the delivery log, not derived from grants.
-     */
-    deliveries: InboxDeliveryRef[];
-    /** True when there was more than one envelope's worth; the rest stay unacked. */
-    deliveriesCapped: boolean;
-    /** The chat-bearing deliveries above, folded by chat. */
-    chats: InboxChatNews[];
-    /**
-     * Pass to `ack()` after acting. Null when there is nothing to ack. Ack after
-     * acting, not after reading: a crash in between redelivers.
-     */
-    ackTo: string | null;
-    /** Open tasks assigned to this agent — the work channel (ZIG-973). */
-    tasksAwaitingMe: InboxTaskRef[];
-    truncatedTasks: number;
-    proposalsAwaitingMe: InboxProposalRef[];
-    truncatedProposals: number;
-    connectionRequestsAwaitingMe: InboxConnectionRequestRef[];
-    truncatedConnectionRequests: number;
-    humanAttention?: InboxHumanAttention;
-}
-export interface InboxAckResult {
-    /** Where the watermark now sits. Monotonic — a rewind is a no-op, not an error. */
-    ackedUpTo: string | null;
-}
-/**
- * Long-poll option shared by the inbox reads. The server holds the request up
- * to this many seconds (server-clamped, ~25s ceiling) and returns as soon as
- * anything actionable exists. Omit for an immediate snapshot — the response
- * shape is identical either way, so `wait` only changes how long an EMPTY
- * answer is withheld.
- */
-export interface InboxReadOptions {
-    waitSeconds?: number;
-    /**
-     * Operator read only (ZIG-965): restrict the sweep to this roster. The
-     * server intersects it with the agents the key owner runs — it narrows,
-     * never widens. A launcher hosting a subset should always pass the agents
-     * it actually registered, or it pays for a sweep of the owner's whole
-     * seeded fleet.
-     */
-    agents?: string[];
-}
-/**
- * One agent's line in the operator sweep: enough to decide whether to start a
- * host, and nothing more.
- *
- * Deliberately NOT that agent's envelope. The launcher only chooses who to
- * run; the host it starts reads its own inbox on its own credentials a moment
- * later, so building N envelopes here was work thrown away.
- */
-export interface InboxOperatorAgentEntry {
-    agentId: string;
-    /** Newest delivery addressed to this agent, or null if it never had one. */
-    deliveredUpTo: string | null;
-    /** How far it has acked. Mail exists when `deliveredUpTo > ackedUpTo`. */
-    ackedUpTo: string | null;
-    /**
-     * True when this agent holds open assigned work. Independent of the
-     * watermark: a host that died mid-task already acked past the task's
-     * delivery, and the open task is the only durable trace it needs restarting.
-     */
-    hasOpenTasks: boolean;
-}
-/** GET /inbox/operator: which of the key owner's agents have mail or open work. */
-export interface InboxOperatorEnvelope {
-    asOf: string;
-    /** Agents with mail or open work. */
-    agents: InboxOperatorAgentEntry[];
-    /** Agents examined that had neither. */
-    idleAgents: number;
-    /** Owned agents beyond the server's per-pass cap — not examined. */
-    truncatedAgents: number;
-}
+import type { InboxAckResult, InboxEnvelope, InboxReadOptions } from '../types.js';
 /**
  * The doorbell, not the door (ZIG-434): references addressed to this agent
  * since its last ack — never content. Flow: inbox → read → act → ack
@@ -184,14 +16,6 @@ export declare class InboxClient {
     private headers;
     private inboxUrl;
     getInbox(opts?: InboxReadOptions): Promise<InboxEnvelope>;
-    /**
-     * Operator-level multiplexed read: which of this key owner's agents have
-     * mail or open work (an agent-scoped key collapses to its one agent).
-     *
-     * Returns who to start, never what they were sent — the host you start
-     * reads its own inbox on its own identity. Ack stays per agent.
-     */
-    getOperatorInbox(opts?: InboxReadOptions): Promise<InboxOperatorEnvelope>;
     /**
      * Advance this agent's watermark — pass the envelope's `ackTo`. Monotonic
      * server-side: an older value is a no-op, so a replayed ack can never

package/dist/http/InboxClient.js

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { pollSurfaceError } from '../shared/rateLimit.js';
 /**
@@ -35,9 +34,6 @@ export class InboxClient {
         if (opts.waitSeconds != null && opts.waitSeconds > 0) {
             url.searchParams.set('wait', String(opts.waitSeconds));
         }
-        if (opts.agents?.length) {
-            url.searchParams.set('agents', opts.agents.join(','));
-        }
         return url.toString();
     }
     async getInbox(opts = {}) {
@@ -50,42 +46,6 @@ export class InboxClient {
         }
         return JSON.parse(body);
     }
-    /**
-     * Operator-level multiplexed read: which of this key owner's agents have
-     * mail or open work (an agent-scoped key collapses to its one agent).
-     *
-     * Returns who to start, never what they were sent — the host you start
-     * reads its own inbox on its own identity. Ack stays per agent.
-     */
-    async getOperatorInbox(opts = {}) {
-        // Bounded wait (ZIG-965): the server holds at most `waitSeconds` (+ sweep
-        // time); a poll that outlives that by a wide margin is a dead sweep, and
-        // without a timeout it blocked the launcher's whole poll loop — lazy wake
-        // simply stopped. Abort and let the caller's retry loop take over.
-        const timeoutMs = ((opts.waitSeconds ?? 0) + 30) * 1000;
-        const ac = new AbortController();
-        const timer = setTimeout(() => ac.abort(), timeoutMs);
-        let res;
-        try {
-            res = await fetch(this.inboxUrl('/inbox/operator', opts), {
-                headers: this.headers(),
-                signal: ac.signal,
-            });
-        }
-        catch (err) {
-            throw ac.signal.aborted
-                ? new Error(`InboxClient.getOperatorInbox timed out after ${timeoutMs}ms`)
-                : err;
-        }
-        finally {
-            clearTimeout(timer);
-        }
-        const body = await res.text().catch(() => '');
-        if (!res.ok) {
-            throw pollSurfaceError('InboxClient.getOperatorInbox', res, body);
-        }
-        return JSON.parse(body);
-    }
     /**
      * Advance this agent's watermark — pass the envelope's `ackTo`. Monotonic
      * server-side: an older value is a no-op, so a replayed ack can never

package/dist/http/MarketplaceClient.d.ts

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 import { type Creds, type Agreement, type BroadcastAudience } from '../types.js';
 export interface PublishOfferPayload {
     description: string;

package/dist/http/MarketplaceClient.js

@@ -1,4 +1,5 @@
-import 'dotenv/config';
+// ZIG-1111: one shaping rule for every agreement this package parses.
+import { shapeAgreement } from './AgreementClient.js';
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { throwApiError } from '../shared/apiError.js';
 function getMarketplaceBaseUrl() { return `${getBackendUrl()}/marketplace`; }
@@ -30,7 +31,7 @@ export async function publishOffer(payload, creds) {
         throwApiError(res, body, `Marketplace offer publish failed: ${res.status}`);
     }
     const data = await res.json().catch(() => null);
-    return (data?.['offer'] ?? data);
+    return shapeAgreement((data?.['offer'] ?? data));
 }
 export async function pullOffers(options, creds) {
     assertCreds(creds, 'marketplace offers pull');
@@ -67,7 +68,7 @@ export async function claimOffer(agreementId, creds) {
     const data = await res.json().catch(() => null);
     if (!data?.['ok'])
         throw new Error(data?.['error'] || 'Claim failed');
-    return data['offer'];
+    return shapeAgreement(data['offer']);
 }
 export async function publishQuest(payload, creds) {
     assertCreds(creds, 'quest publish');
@@ -83,7 +84,7 @@ export async function publishQuest(payload, creds) {
     const data = await res.json().catch(() => null);
     if (!data?.['agreement'])
         throw new Error('Quest publish returned no agreement');
-    return data['agreement'];
+    return shapeAgreement(data['agreement']);
 }
 export async function pullQuests(options, creds) {
     assertCreds(creds, 'quest pull');

package/dist/http/MessagesClient.d.ts

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 export interface ListMessagesOptions {
     /** ISO timestamp; only entries with `timestamp > after` are returned. */
     after?: string;

package/dist/http/MessagesClient.js

@@ -1,5 +1,5 @@
-import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
 /**
  * Read-side client for forward-delta message reads.
  *
@@ -35,11 +35,8 @@ export class MessagesClient {
         const res = await fetch(url.toString(), { headers: this._headers() });
         if (!res.ok) {
             const body = await res.text().catch(() => '');
-            const err = new Error(`MessagesClient.list ${res.status} ${res.statusText} ${body.slice(0, 200)}`);
-            // Callers branch on the HTTP status (404 = chat deleted/not visible)
-            // without parsing the message string.
-            err.status = res.status;
-            throw err;
+            // Callers branch on ApiError.status (404 = chat deleted/not visible).
+            throwApiError(res, body, `MessagesClient.list failed: ${res.status}`);
         }
         return (await res.json());
     }

package/dist/http/OrgsClient.d.ts

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 import type { Creds } from '../types.js';
 export interface MyOrg {
     orgId: string;

package/dist/http/OrgsClient.js

@@ -1,5 +1,5 @@
-import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 /**
  * ZIG-739 / ZIG-956 — the operator's full org membership (not just granted
@@ -15,7 +15,7 @@ export async function fetchMyOrgs(creds, baseUrl) {
     });
     const body = await res.text().catch(() => '');
     if (!res.ok) {
-        throw new Error(`GET /orgs/me ${res.status} ${body.slice(0, 200)}`);
+        throwApiError(res, body, `GET /orgs/me failed: ${res.status}`);
     }
     const parsed = body ? JSON.parse(body) : {};
     return (parsed.orgs ?? []).map((o) => ({
@@ -55,7 +55,7 @@ export async function fetchDelegateAccess(creds, baseUrl) {
     });
     const body = await res.text().catch(() => '');
     if (!res.ok) {
-        throw new Error(`GET /agents/claude-delegate/access ${res.status} ${body.slice(0, 200)}`);
+        throwApiError(res, body, `GET /agents/claude-delegate/access failed: ${res.status}`);
     }
     return body ? JSON.parse(body) : {};
 }

package/dist/http/PaymentsClient.d.ts

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 import type { GrantView } from './grants.js';
 /** Thrown by PaymentsClient with the HTTP status and raw body attached. */
 export interface PaymentsError extends Error {
@@ -101,11 +100,14 @@ export declare class PaymentsClient {
         description?: string;
         paymentGrantId?: string;
     }): Promise<TransferResult>;
-    hold({ amount, idempotencyKey, description, }: {
+    hold({ amount, idempotencyKey, description, paymentGrantId, }: {
         amount: number;
         idempotencyKey?: string;
         description?: string;
+        paymentGrantId?: string;
     }): Promise<HoldResult>;
+    /** Prefer a single active wallet grant the agent already holds (ZIG-1182). */
+    private resolveAgentPaymentGrantId;
     release({ holdId, action, toWalletId, idempotencyKey, }: {
         holdId: string;
         action?: string;

package/dist/http/PaymentsClient.js

@@ -1,8 +1,7 @@
-import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 import { GrantsClient } from './GrantsClient.js';
-import { parseErrorMessage } from '../shared/apiError.js';
+import { throwApiError } from '../shared/apiError.js';
 function randomIdempotencyKey(prefix = 'op') {
     return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
 }
@@ -51,6 +50,11 @@ export class PaymentsClient {
             throw new Error('transfer: `to` is required');
         if (!(Number.isInteger(amount) && amount > 0))
             throw new Error('transfer: `amount` must be a positive integer (cents)');
+        // ZIG-1182 — resolve a standing/active grant when the caller omitted one
+        // (Claude/MCP ensureForUser mints it). Explicit id still wins.
+        if (this.agentId && !paymentGrantId) {
+            paymentGrantId = (await this.resolveAgentPaymentGrantId()) ?? undefined;
+        }
         if (this.agentId && !paymentGrantId)
             throw new Error('transfer: paymentGrantId is required for agent-impersonated transfers. The wallet owner must have issued a payment grant to this agentId.');
         let toWalletId = to;
@@ -86,15 +90,33 @@ export class PaymentsClient {
             amount,
         };
     }
-    async hold({ amount, idempotencyKey, description, }) {
+    async hold({ amount, idempotencyKey, description, paymentGrantId, }) {
         if (!(Number.isInteger(amount) && amount > 0))
             throw new Error('hold: `amount` must be a positive integer (cents)');
+        // ZIG-1182 — agent holds reserve the owner's wallet; require a grant.
+        if (this.agentId && !paymentGrantId) {
+            paymentGrantId = (await this.resolveAgentPaymentGrantId()) ?? undefined;
+        }
+        if (this.agentId && !paymentGrantId)
+            throw new Error('hold: paymentGrantId is required for agent-impersonated holds. The wallet owner must have issued a payment grant to this agentId.');
         return (await this._post('/payments/hold', {
             amount,
             idempotencyKey: idempotencyKey || randomIdempotencyKey('hold'),
             description,
+            paymentGrantId,
         }));
     }
+    /** Prefer a single active wallet grant the agent already holds (ZIG-1182). */
+    async resolveAgentPaymentGrantId() {
+        try {
+            const grants = await this.listGrants();
+            const id = grants[0]?.grantId;
+            return typeof id === 'string' && id.length > 0 ? id : null;
+        }
+        catch {
+            return null;
+        }
+    }
     async release({ holdId, action = 'complete', toWalletId, idempotencyKey, }) {
         return (await this._post(`/payments/release/${holdId}`, {
             idempotencyKey: idempotencyKey || randomIdempotencyKey('rel'),
@@ -217,10 +239,8 @@ export class PaymentsClient {
         const response = await fetch(`${this.baseUrl}${path}`, init);
         const text = await response.text();
         if (!response.ok) {
-            const err = new Error(parseErrorMessage(text, `HTTP ${response.status}`));
-            err.status = response.status;
-            err.body = text;
-            throw err;
+            // ZIG-1124 — ApiError; PaymentsError remains the duck type for `.status`.
+            throwApiError(response, text, `HTTP ${response.status}`);
         }
         return text ? JSON.parse(text) : null;
     }

package/dist/http/TaskClient.d.ts

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 import { type Creds, type Task, type TaskState } from '../types.js';
 /**
  * When the buyer reviews a task's plan. Task-rail only — an agreement has no

package/dist/http/TaskClient.js

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { throwApiError } from '../shared/apiError.js';
 function getTaskBaseUrl() { return `${getBackendUrl()}/tasks`; }

package/dist/http/TelemetryClient.d.ts

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 export declare class TelemetryClient {
     private readonly operatorKey;
     private readonly agentId?;

package/dist/http/TelemetryClient.js

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 import { runtimeLog } from '../shared/runtimeLog.js';
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';

package/dist/http/agreementFlows.d.ts

@@ -1,4 +1,4 @@
-import { type ProposeTerms } from './AgreementClient.js';
+import { type ClaimedKind, type ProposeTerms } from './AgreementClient.js';
 import { type Agreement, type Creds, type EngagementKind } from '../types.js';
 /**
  * ZIG-1022 — one propose grammar. Direct, broadcast (quest and standing
@@ -22,11 +22,19 @@ export declare function proposeUnified(input: UnifiedProposeInput, creds: Creds)
     agreement: Agreement;
     shape: ProposeShape;
 }>;
-export type ClaimedKind = 'link' | 'offer' | 'quest' | 'hand-off';
 /**
- * ZIG-1021 — one claim verb for any open broadcast. Fetches the agreement to
- * route: link invites and quests claim through POST /agreements/:id/claim;
- * standing offers (open payer side) through POST /marketplace/offers/claim.
+ * ZIG-1021 — one claim verb for any open broadcast: link invite, quest,
+ * hand-off, or standing offer.
+ *
+ * One request. This used to read the agreement first to decide which endpoint to
+ * post to, and `GET /agreements/:id` is party-scoped — a claimer is by definition
+ * not yet a party to the broadcast it is claiming, so the routing read 404'd and
+ * every standing offer in the store failed with "Agreement not found" before
+ * either claim endpoint was called (ZIG-1155). The backend routes it now, where
+ * the row is readable without being a party to it.
+ *
+ * `kind` arrives on the claim response — the route that did the routing reports
+ * which broadcast kind this turned out to be.
  */
 export declare function claimOpenAgreement(agreementId: string, creds: Creds): Promise<{
     agreement: Agreement;

package/dist/http/agreementFlows.js

@@ -1,5 +1,5 @@
-import { createAgreement, claimAgreement, getAgreement, proposeBroadcast, proposeDirectTo, } from './AgreementClient.js';
-import { claimOffer, publishOffer } from './MarketplaceClient.js';
+import { createAgreement, claimAgreement, proposeBroadcast, proposeDirectTo, } from './AgreementClient.js';
+import { publishOffer } from './MarketplaceClient.js';
 import { isBroadcastTarget, } from '../types.js';
 export async function proposeUnified(input, creds) {
     const { proposedTo, chatId, engagementKind, providerId, ...terms } = input;
@@ -56,30 +56,24 @@ export async function proposeUnified(input, creds) {
     return { agreement, shape: 'direct' };
 }
 /**
- * ZIG-1021 — one claim verb for any open broadcast. Fetches the agreement to
- * route: link invites and quests claim through POST /agreements/:id/claim;
- * standing offers (open payer side) through POST /marketplace/offers/claim.
+ * ZIG-1021 — one claim verb for any open broadcast: link invite, quest,
+ * hand-off, or standing offer.
+ *
+ * One request. This used to read the agreement first to decide which endpoint to
+ * post to, and `GET /agreements/:id` is party-scoped — a claimer is by definition
+ * not yet a party to the broadcast it is claiming, so the routing read 404'd and
+ * every standing offer in the store failed with "Agreement not found" before
+ * either claim endpoint was called (ZIG-1155). The backend routes it now, where
+ * the row is readable without being a party to it.
+ *
+ * `kind` arrives on the claim response — the route that did the routing reports
+ * which broadcast kind this turned out to be.
  */
 export async function claimOpenAgreement(agreementId, creds) {
     if (!agreementId)
         throw new Error('agreementId is required');
-    const existing = await getAgreement(agreementId, creds);
-    if (!existing)
-        throw new Error(`Agreement not found: ${agreementId}`);
-    if (existing.engagementKind === 'link') {
-        const { agreement } = await claimAgreement(agreementId, creds);
-        return { agreement, kind: 'link' };
-    }
-    if (isBroadcastTarget(existing.parties?.payer)) {
-        // Seller-broadcast standing offer: the open side is the payer — you buy.
-        const agreement = await claimOffer(agreementId, creds);
-        return { agreement, kind: 'offer' };
-    }
-    const { agreement } = await claimAgreement(agreementId, creds);
-    // ZIG-1059: a pinned provider inverts the quest reading — the publisher's
-    // hired agent does the work and the claimer is who it is done FOR.
-    return {
-        agreement,
-        kind: existing.providerPinned === true ? 'hand-off' : 'quest',
-    };
+    const { agreement, kind } = await claimAgreement(agreementId, creds);
+    // A server that has not shipped the `kind` field yet still claims correctly;
+    // 'quest' is the shape the route has always handled.
+    return { agreement, kind: kind ?? 'quest' };
 }

package/dist/http/index.d.ts

@@ -26,4 +26,3 @@ export type { MyOrg, OrgResolution } from './OrgsClient.js';
 export { AgentSearchClient } from './AgentSearchClient.js';
 export { TelemetryClient } from './TelemetryClient.js';
 export { InboxClient } from './InboxClient.js';
-export type { InboxDeliveryKind, InboxDeliveryRef, InboxChatNews, InboxProposalRef, InboxTaskRef, InboxConnectionRequestRef, InboxHumanAttention, InboxEnvelope, InboxAckResult, InboxOperatorAgentEntry, InboxOperatorEnvelope, } from './InboxClient.js';

package/dist/index.d.ts

@@ -2,12 +2,14 @@ export * from './http/index.js';
 export * from './capabilities/index.js';
 export * from './relay/provisionRelayWorkers.js';
 export { ConnectionManager } from './ConnectionManager.js';
-export type { StartAgentOptions } from './ConnectionManager.js';
 export { EntryTypes, ContentTypes, OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET, BROADCAST_TARGETS, isBroadcastTarget, isPersonaRef, isRoomPresentationRef, isOpaquePresentationRef, AGREEMENT_ENGAGEMENT_KIND, isValidContentType, } from './types.js';
 export type { PrincipalPresentation } from './types.js';
 export { getBackendUrl, getWebSocketUrl } from './utils/urlUtils.js';
+export { configureApiClient, apiClientConfig } from './config.js';
+export type { ApiClientConfig, ApiClientLogLevel } from './config.js';
 export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';
 export { RateLimitedError, isRateLimited, parseRetryAfterMs, pollSurfaceError, } from './shared/rateLimit.js';
-export { parseErrorMessage, throwApiError } from './shared/apiError.js';
-export type { Creds, Task, TaskState, PlanStep, PlanStepStatus, Agreement, EngagementKind, BroadcastAudience, EntryType, ContentType, MessageMetadata, MessageHandler, ApiError, } from './types.js';
+export { parseErrorMessage, parseErrorCode, throwApiError, } from './shared/apiError.js';
+export { ApiError } from './types.js';
+export type { Creds, Task, TaskState, PlanStep, PlanStepStatus, Agreement, EngagementKind, BroadcastAudience, EntryType, ContentType, MessageMetadata, MessageHandler, InboxDeliveryKind, InboxDeliveryRef, InboxChatNews, InboxProposalRef, InboxTaskRef, InboxQuestRef, InboxConnectionRequestRef, InboxHumanAttention, InboxEnvelope, InboxAckResult, InboxReadOptions, } from './types.js';
 export type { ProposeTerms, ProposeDirectInput, ProposeBroadcastInput, ProposeAgreementData, } from './http/AgreementClient.js';

package/dist/index.js

@@ -4,10 +4,13 @@ export * from './relay/provisionRelayWorkers.js';
 export { ConnectionManager } from './ConnectionManager.js';
 export { EntryTypes, ContentTypes, OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET, BROADCAST_TARGETS, isBroadcastTarget, isPersonaRef, isRoomPresentationRef, isOpaquePresentationRef, AGREEMENT_ENGAGEMENT_KIND, isValidContentType, } from './types.js';
 export { getBackendUrl, getWebSocketUrl } from './utils/urlUtils.js';
+// ZIG-652: the host injects the environment; this package never reads it.
+export { configureApiClient, apiClientConfig } from './config.js';
 export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';
-// ZIG-1019: retry loops need the server's own wait, not a guess.
+// ZIG-1019 / ZIG-1124: one ApiError shape; 429s carry the server's wait.
 export { RateLimitedError, isRateLimited, parseRetryAfterMs, pollSurfaceError, } from './shared/rateLimit.js';
 // One reader for the one error shape the API answers in — exported so nothing has
 // to re-implement the field precedence (it was copy-pasted into six clients, and
 // half of them had drifted).
-export { parseErrorMessage, throwApiError } from './shared/apiError.js';
+export { parseErrorMessage, parseErrorCode, throwApiError, } from './shared/apiError.js';
+export { ApiError } from './types.js';

package/dist/shared/apiError.d.ts

@@ -16,7 +16,28 @@
  * so the same failure read differently depending on which client you called.
  */
 export declare function parseErrorMessage(responseBody: string, defaultMessage: string): string;
-/** Throw the parsed failure as an {@link ApiError}, preserving status and body. */
+/** Machine code from `{ error, code }` when the filter (or thrower) supplied one. */
+export declare function parseErrorCode(responseBody: string): string | null;
+/**
+ * Read the wait out of a 429 response. `Retry-After` wins (it is the explicit
+ * one) and is accepted in both forms — delta-seconds or an HTTP date;
+ * `RateLimit-Reset` is the standard-headers fallback, in seconds. Capped so a
+ * bad header cannot park a loop for an hour, floored at a second so a `0` does
+ * not reproduce the hot-retry it is meant to stop.
+ *
+ * Lives next to {@link throwApiError} so every client path (not only the poll
+ * surface) can honour the server's number (ZIG-1124).
+ */
+export declare function parseRetryAfterMs(headers: {
+    get(name: string): string | null;
+}): number | null;
+/**
+ * Throw the parsed failure as an {@link ApiError} (or {@link RateLimitedError}
+ * for 429), preserving status, body, machine code, and Retry-After.
+ */
 export declare function throwApiError(response: {
     status: number;
+    headers?: {
+        get(name: string): string | null;
+    };
 }, responseBody: string, defaultMessage: string): never;