@ziggs-ai/api-client 0.9.0 → 0.9.1

package/dist/http/AgreementClient.js

@@ -25,6 +25,54 @@ function assertCreds(creds, op) {
     if (!creds?.agentId)
         throw new Error(`agentId is required for ${op}`);
 }
+/**
+ * A trust link's agreement, as every caller sees it.
+ *
+ * A link is reach, not commerce: it carries no money, no escrow, no execution
+ * state and no approvals ledger. Handing the raw document over anyway put Mongo
+ * bookkeeping in front of an LLM, which is what ZIG-957 forbade.
+ *
+ * Lives here rather than in `capabilities/links.ts` because this is where the
+ * rule is applied (ZIG-1111); that module re-exports it so the public name is
+ * unchanged.
+ */
+export function linkSummary(a) {
+    return {
+        agreementId: a.agreementId,
+        // Kept deliberately: callers branch on this, and a summary that hides what
+        // kind of thing it describes breaks the code it is meant to protect.
+        engagementKind: a.engagementKind,
+        status: a.status,
+        proposalStatus: a.proposalStatus,
+        parties: {
+            creatorAgent: a.parties?.creatorAgent ?? null,
+            providerAgent: a.parties?.providerAgent ?? null,
+            creator: a.parties?.creator ?? null,
+            proposedTo: a.parties?.proposedTo ?? null,
+        },
+        ...(a.description ? { description: a.description } : {}),
+        // Seat bookkeeping on an open invite — link state, not commerce.
+        ...(a.linkInvite ? { linkInvite: a.linkInvite } : {}),
+        createdAt: a.createdAt,
+    };
+}
+/**
+ * Every agreement document this client parses passes through here.
+ *
+ * The rule — a link is returned as its summary, anything else verbatim — used to
+ * be written out at six call sites across the SDK runner, the MCP tools and the
+ * capability layer, and three verbs never got it: `agreement_counter`,
+ * `agreement_fulfill` and `agreement_subcontract` returned the raw document
+ * (ZIG-1111). Applying it at the parse boundary means a new verb inherits the
+ * rule instead of remembering to opt in, and no surface can word its own verdict.
+ *
+ * Typed as `Agreement` on the way out: every key the summary keeps IS an
+ * Agreement field, so this narrows a document rather than returning a different
+ * shape.
+ */
+export function shapeAgreement(a) {
+    return a.engagementKind === 'link' ? linkSummary(a) : a;
+}
 export async function proposeAgreement(proposalData, creds) {
     if (!proposalData)
         throw new Error('Proposal data is required for proposal creation');
@@ -48,7 +96,7 @@ export async function proposeAgreement(proposalData, creds) {
     if (!data?.['agreement']) {
         throw new Error('Invalid response: expected { agreement } from POST /agreements/proposals');
     }
-    return data['agreement'];
+    return shapeAgreement(data['agreement']);
 }
 /** Propose a contract to one party (user or agent). Server defaults `engagementKind` to `service`. */
 export async function proposeDirectTo(input, creds) {
@@ -96,7 +144,7 @@ export async function delegateAgreement(proposalData, creds) {
     if (!data?.['agreement']) {
         throw new Error('Invalid response: expected { agreement } from POST /agreements/:parentAgreementId/delegations');
     }
-    return data['agreement'];
+    return shapeAgreement(data['agreement']);
 }
 /**
  * Approve or reject a pending agreement (ZIG-524 canonical client path).
@@ -110,7 +158,10 @@ export async function respondToAgreement(agreementId, action, creds, opts = {})
     if (!agreementId || !action)
         throw new Error('Agreement ID and action are required for proposal response');
     assertCreds(creds, 'proposal response');
-    const agreement = opts.agreement ?? (await getAgreement(agreementId, creds));
+    // Unshaped on purpose: the approvals ledger below is exactly what the link
+    // summary drops, and resolving the caller's slot from a summary would fail
+    // every link approval with "no pending approval entry".
+    const agreement = opts.agreement ?? (await getAgreementDocument(agreementId, creds));
     if (!agreement) {
         throw new Error(`Agreement ${agreementId} not found`);
     }
@@ -213,7 +264,7 @@ export async function approveAgreementAsParty(agreementId, partyId, status, cred
     if (!data?.['agreement']) {
         throw new Error('Invalid response: expected { agreement } from PUT /agreements/:id/approvals/:partyId');
     }
-    return data['agreement'];
+    return shapeAgreement(data['agreement']);
 }
 export async function counterAgreement(agreementId, counter, creds) {
     if (!agreementId)
@@ -232,7 +283,7 @@ export async function counterAgreement(agreementId, counter, creds) {
     if (!data?.['agreement']) {
         throw new Error('Invalid response: expected { agreement } from /agreements/:id/counter');
     }
-    return data['agreement'];
+    return shapeAgreement(data['agreement']);
 }
 export async function getAgreementStatus(agreementId, creds) {
     if (!agreementId)
@@ -261,8 +312,7 @@ export async function listAgreements(filters = {}, creds) {
     assertCreds(creds, 'list agreements');
     // ZIG-699 — return an empty array only for a genuine empty 200 result. Any
     // failure (non-2xx / network) throws so the MCP tool reports a real error
-    // instead of "you have no agreements". The status stays whitespace-delimited
-    // so the tool's toolError/classifyToolError maps it to a stable code.
+    // instead of "you have no agreements". ZIG-1124 — HTTP failures are ApiError.
     // Canonical query path: GET /agreements?scope=&status=&engagementKind=&...
     const url = new URL(getAgreementBaseUrl());
     if (filters.status)
@@ -284,10 +334,12 @@ export async function listAgreements(filters = {}, creds) {
     if (!res.ok) {
         const body = await res.text().catch(() => '');
         runtimeLog.warn('AgreementClient', `⚠️ List agreements failed: ${res.status} ${res.statusText} ${body?.slice(0, 200)}`);
-        throw new Error(`GET /agreements ${res.status} ${body?.slice(0, 200)}`);
+        throwApiError(res, body, `GET /agreements failed: ${res.status}`);
     }
     const data = await res.json().catch(() => null);
-    return Array.isArray(data?.['agreements']) ? data['agreements'] : [];
+    return Array.isArray(data?.['agreements'])
+        ? data['agreements'].map(shapeAgreement)
+        : [];
 }
 export async function getMyAgreements(filters = {}, creds) {
     assertCreds(creds, 'get my agreements');
@@ -316,20 +368,29 @@ export async function getMyAgreements(filters = {}, creds) {
     if (!res.ok) {
         const body = await res.text().catch(() => '');
         runtimeLog.warn('AgreementClient', `⚠️ Get my agreements failed: ${res.status} ${res.statusText} ${body?.slice(0, 200)}`);
-        throw new Error(`GET /agreements?scope=mine ${res.status} ${body?.slice(0, 200)}`);
+        throwApiError(res, body, `GET /agreements?scope=mine failed: ${res.status}`);
     }
     const data = await res.json().catch(() => null);
-    return Array.isArray(data?.['agreements']) ? data['agreements'] : [];
+    return Array.isArray(data?.['agreements'])
+        ? data['agreements'].map(shapeAgreement)
+        : [];
 }
-export async function getAgreement(agreementId, creds) {
+/**
+ * The full agreement document, unshaped — for this client's OWN reads.
+ *
+ * `respondToAgreement` resolves which approvals slot the caller may fill, and
+ * `claimOpenAgreement` routes on the broadcast's open side; both need fields the
+ * link summary deliberately drops. Callers outside this module get the shaped
+ * `getAgreement`.
+ */
+async function getAgreementDocument(agreementId, creds) {
     if (!agreementId)
         return null;
     assertCreds(creds, 'get agreement');
     // ZIG-698 — a genuine 404 (and 200-with-no-agreement) is a real "not found"
     // and returns null. Every other failure (403/5xx/network) must throw so the
     // caller can tell "does not exist" from "could not fetch" instead of a 403
-    // masquerading as not-found. The MCP tool classifies the thrown status via
-    // toolError; the message keeps the status whitespace-delimited for that.
+    // masquerading as not-found. ZIG-1124 — thrown as ApiError for toolError.
     let res;
     try {
         res = await fetch(`${getAgreementBaseUrl()}/${agreementId}`, {
@@ -346,11 +407,16 @@ export async function getAgreement(agreementId, creds) {
     if (!res.ok) {
         const body = await res.text().catch(() => '');
         runtimeLog.warn('AgreementClient', `⚠️ Get agreement failed: ${res.status} ${res.statusText} ${body?.slice(0, 200)}`);
-        throw new Error(`GET /agreements/${agreementId} ${res.status} ${body?.slice(0, 200)}`);
+        throwApiError(res, body, `GET /agreements/${agreementId} failed: ${res.status}`);
     }
     const data = await res.json().catch(() => null);
     return data?.['agreement'] ?? null;
 }
+/** One agreement, shaped: a link comes back as its summary. */
+export async function getAgreement(agreementId, creds) {
+    const agreement = await getAgreementDocument(agreementId, creds);
+    return agreement ? shapeAgreement(agreement) : null;
+}
 export async function createAgreement(body, creds) {
     if (!body)
         throw new Error('Body is required for agreement creation');
@@ -369,7 +435,8 @@ export async function createAgreement(body, creds) {
     if (!data?.['agreement']) {
         throw new Error('Invalid response: expected { ok, agreement } from POST /agreements');
     }
-    return data;
+    const envelope = data;
+    return { ...envelope, agreement: shapeAgreement(envelope.agreement) };
 }
 export async function revokeAgreement(agreementId, creds) {
     if (!agreementId)
@@ -389,7 +456,8 @@ export async function revokeAgreement(agreementId, creds) {
     if (!data?.['agreement']) {
         throw new Error('Invalid response: expected { ok, agreement } from DELETE /agreements/:id');
     }
-    return data;
+    const envelope = data;
+    return { ...envelope, agreement: shapeAgreement(envelope.agreement) };
 }
 /** ZIG-832: mark an agreement fulfilled (complete). A provider closing its own
  * delivered work — party-gated server-side. */
@@ -409,7 +477,8 @@ export async function fulfillAgreement(agreementId, creds) {
     if (!data?.['agreement']) {
         throw new Error('Invalid response: expected { ok, agreement } from POST /agreements/:id/fulfill');
     }
-    return data;
+    const envelope = data;
+    return { ...envelope, agreement: shapeAgreement(envelope.agreement) };
 }
 /**
  * Claim an open agreement (ZIG-524 phase 2 / ZIG-525):
@@ -433,7 +502,12 @@ export async function claimAgreement(agreementId, creds) {
     if (!data?.['agreement']) {
         throw new Error('Invalid response: expected { ok, agreement } from POST /agreements/:id/claim');
     }
-    return data;
+    // ZIG-1155: the route reports which kind of broadcast this turned out to be.
+    // A caller cannot work it out from the row — post-claim no sentinel is left,
+    // and a quest (you do the work) reads the same shape as a standing offer (you
+    // pay for it) unless you know which slot you landed in.
+    const envelope = data;
+    return { ...envelope, agreement: shapeAgreement(envelope.agreement) };
 }
 // ---------------------------------------------------------------------------
 // Chat links

package/dist/http/ChatClient.js

@@ -104,7 +104,7 @@ export async function listMyChats(creds) {
     assertCreds(creds, 'list my chats');
     // ZIG-699 — empty array only for a genuine empty 200; any failure (non-2xx /
     // network) throws so ziggs_chat_list reports a real error instead of "you
-    // have no chats". Status stays whitespace-delimited for toolError classification.
+    // have no chats". ZIG-1124 — HTTP failures are ApiError (status/body/code).
     let res;
     try {
         res = await fetch(`${getBackendUrl()}/chats/mine`, {
@@ -119,7 +119,7 @@ export async function listMyChats(creds) {
     if (!res.ok) {
         const body = await res.text().catch(() => '');
         runtimeLog.warn('ChatClient', `⚠️ listMyChats failed: ${res.status} ${res.statusText} ${body?.slice(0, 200)}`);
-        throw new Error(`GET /chats/mine ${res.status} ${body?.slice(0, 200)}`);
+        throwApiError(res, body, `GET /chats/mine failed: ${res.status}`);
     }
     const data = await res.json().catch(() => null);
     return Array.isArray(data?.['chats']) ? data['chats'] : [];

package/dist/http/ConnectionsClient.js

@@ -1,5 +1,6 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 import { GrantsClient } from './GrantsClient.js';
 // ZIG-569 — defense-in-depth mirror of the backend leak-guard
@@ -169,10 +170,9 @@ export class ConnectionsClient {
         const response = await fetch(`${this.baseUrl}${path}`, init);
         const text = await response.text().catch(() => '');
         if (!response.ok) {
-            const err = new Error(`${method} ${path} ${response.status} ${text.slice(0, 200)}`);
-            err.status = response.status;
-            err.body = text;
-            throw err;
+            // ZIG-1124 — ApiError (status/body/code); ConnectionsError remains the
+            // documented duck type for callers that branch on `.status`.
+            throwApiError(response, text, `${method} ${path} failed: ${response.status}`);
         }
         return text;
     }

package/dist/http/ContextDiscoveryClient.js

@@ -1,5 +1,6 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 /**
  * P4 discovery — labels-only pointers to context the agent could REQUEST but
@@ -34,7 +35,7 @@ export class ContextDiscoveryClient {
         });
         const body = await res.text().catch(() => '');
         if (!res.ok) {
-            throw new Error(`ContextDiscoveryClient.discoverGrantable ${res.status} ${body.slice(0, 200)}`);
+            throwApiError(res, body, `ContextDiscoveryClient.discoverGrantable failed: ${res.status}`);
         }
         const parsed = JSON.parse(body);
         return (parsed.items ?? []).map((i) => ({

package/dist/http/ContextReadClient.js

@@ -105,18 +105,11 @@ export class ContextReadClient {
         const res = await fetch(url.toString(), { headers });
         const body = await res.text().catch(() => '');
         if (!res.ok) {
-            // Carry the status like `snapshot()` does, so callers can branch on it.
             // A 403 here is a legitimate outcome, not a transport failure: addressing
             // and authorisation are separate, so an agent can be told about mail it
-            // is not (or is no longer) allowed to open.
-            // ZIG-1019: a 429 carries the server's own wait; everything else keeps
-            // the plain status-tagged error callers already branch on.
-            if (res.status === 429) {
-                throw pollSurfaceError(`ContextReadClient.read ${type}`, res, body);
-            }
-            const err = new Error(`ContextReadClient.read ${type} ${res.status} ${body.slice(0, 200)}`);
-            err.status = res.status;
-            throw err;
+            // is not (or is no longer) allowed to open. ZIG-1124 — one ApiError shape
+            // (429 → RateLimitedError with Retry-After).
+            throw pollSurfaceError(`ContextReadClient.read ${type}`, res, body);
         }
         return JSON.parse(body);
     }
@@ -151,12 +144,8 @@ export class ContextReadClient {
         const res = await fetch(url.toString(), { headers });
         const body = await res.text().catch(() => '');
         if (!res.ok) {
-            if (res.status === 429) {
-                throw pollSurfaceError('ContextReadClient.snapshot', res, body);
-            }
-            const err = new Error(`ContextReadClient.snapshot ${res.status} ${body.slice(0, 200)}`);
-            err.status = res.status;
-            throw err;
+            // ZIG-1124 — ApiError for every non-OK (429 → RateLimitedError).
+            throw pollSurfaceError('ContextReadClient.snapshot', res, body);
         }
         return JSON.parse(body);
     }

package/dist/http/GrantsClient.js

@@ -1,5 +1,6 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 /**
  * ZIG-648 — unified grant listing across every rail. `GET /grants` returns the
@@ -41,7 +42,7 @@ export class GrantsClient {
         });
         const body = await res.text().catch(() => '');
         if (!res.ok) {
-            throw new Error(`GrantsClient.listGrants ${res.status} ${body.slice(0, 200)}`);
+            throwApiError(res, body, `GrantsClient.listGrants failed: ${res.status}`);
         }
         const parsed = JSON.parse(body);
         return {

package/dist/http/InboxClient.d.ts

@@ -127,45 +127,6 @@ export interface InboxAckResult {
  */
 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;
 }
 /**
  * The doorbell, not the door (ZIG-434): references addressed to this agent
@@ -184,14 +145,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

@@ -35,9 +35,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 +47,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.js

@@ -1,4 +1,6 @@
 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 +32,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 +69,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 +85,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.js

@@ -1,5 +1,6 @@
 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 +36,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.js

@@ -1,5 +1,6 @@
 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 +16,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 +56,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.js

@@ -2,7 +2,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)}`;
 }
@@ -217,10 +217,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/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,4 @@ 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';
+export type { InboxDeliveryKind, InboxDeliveryRef, InboxChatNews, InboxProposalRef, InboxTaskRef, InboxConnectionRequestRef, InboxHumanAttention, InboxEnvelope, InboxAckResult, } from './InboxClient.js';