@ziggs-ai/api-client 0.3.1 → 0.5.0

package/dist/capabilities/types.d.ts

@@ -0,0 +1,88 @@
+/**
+ * ZIG-956 — one shared definition per SDK/MCP tool capability.
+ *
+ * The tool-surface-parity epic (ZIG-893→903) unified the HTTP layer here in
+ * api-client but left ~25 shared capabilities hand-written twice: once in the
+ * agent-sdk's defineTool DSL, once in ziggs-mcp zod. Each capability below is
+ * the single source for the tool's schema, validation, response shaping, and
+ * guidance; the two surfaces register it through thin adapters
+ * (agent-sdk `toolFromCapability`, ziggs-mcp `registerCapability`).
+ *
+ * Params are a neutral JSON-schema-flavoured DSL rather than zod because the
+ * two surfaces cannot share one zod: agent-sdk is on zod v4, ziggs-mcp on
+ * zod v3 (pinned by the MCP SDK's ZodRawShape), and api-client deliberately
+ * has no zod dependency. The SDK adapter feeds params straight into
+ * defineTool's converter; the MCP adapter lowers them to zod v3.
+ */
+import type { Creds } from '../types.js';
+export type CapabilitySurface = 'sdk' | 'mcp';
+/** read-only / write / destructive — lowered to MCP tool annotations. */
+export type CapabilityAnnotation = 'read-only' | 'write' | 'destructive';
+export interface CapabilityParam {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required?: boolean;
+    description?: string;
+    /** Only for type 'string'. */
+    enum?: readonly string[];
+    /** Only for type 'array'. */
+    items?: {
+        type: 'string';
+        enum?: readonly string[];
+    } | {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * Runtime context a surface adapter hands the shared handler. `creds.agentId`
+ * may be absent for agent-scoped operator keys (payments rail); capabilities
+ * that impersonate set `needsAgentId` so the adapter fails early instead.
+ */
+export interface CapabilityEnv {
+    creds: {
+        operatorKey: string;
+        agentId?: string;
+    };
+    /** SDK runner base-URL override (BACKEND_URL / ZIGGS_BACKEND_URL). */
+    baseUrl?: string;
+    /** Web-app origin for human-facing URLs (claim links etc.). */
+    webUrl?: string;
+    surface: CapabilitySurface;
+}
+export interface CapabilityDefinition {
+    /** Stable capability key (the parity-table base name), e.g. 'payment_transfer'. */
+    key: string;
+    /** Registered tool name per surface — the ZIG-903 parity table is the authority. */
+    names: {
+        sdk: string;
+        mcp: string;
+    };
+    /**
+     * Tool description per surface. Kept side by side deliberately: wording may
+     * reference surface-local tool names and MCP delegate-protocol guidance, but
+     * schema + handler can no longer drift.
+     */
+    descriptions: {
+        sdk: string;
+        mcp: string;
+    };
+    annotation: CapabilityAnnotation;
+    params: Record<string, CapabilityParam>;
+    /** True when the handler impersonates an agent (X-Agent-Id required). */
+    needsAgentId?: boolean;
+    handler: (args: Record<string, unknown>, env: CapabilityEnv) => Promise<unknown>;
+    /** Pass-through flags for the SDK's defineTool options. */
+    sdkOptions?: {
+        isAgreementCreation?: boolean;
+        isGenericFallback?: boolean;
+    };
+}
+/** Creds for impersonated calls; adapters guarantee agentId when needsAgentId. */
+export declare function fullCreds(env: CapabilityEnv): Creds;
+/**
+ * Re-throw a client error with a capability-level prefix, preserving the HTTP
+ * status/body the clients attach (the SDK runtime and toolError classification
+ * both read them).
+ */
+export declare function rethrowWithContext(error: unknown, prefix: string): never;

package/dist/capabilities/types.js

@@ -0,0 +1,24 @@
+/** Creds for impersonated calls; adapters guarantee agentId when needsAgentId. */
+export function fullCreds(env) {
+    const { operatorKey, agentId } = env.creds;
+    if (!operatorKey)
+        throw new Error('operatorKey missing from tool context');
+    if (!agentId)
+        throw new Error('agentId missing from tool context');
+    return { operatorKey, agentId };
+}
+/**
+ * Re-throw a client error with a capability-level prefix, preserving the HTTP
+ * status/body the clients attach (the SDK runtime and toolError classification
+ * both read them).
+ */
+export function rethrowWithContext(error, prefix) {
+    const e = error;
+    const wrapped = new Error(`${prefix}: ${e.message}`);
+    if (e.status !== undefined)
+        wrapped.status = e.status;
+    if (e.body !== undefined)
+        wrapped.body = e.body;
+    wrapped['cause'] = error;
+    throw wrapped;
+}

package/dist/http/AgreementClient.d.ts

@@ -14,6 +14,12 @@ export interface ProposeTerms {
     lifecycle?: string;
     expiresAt?: string;
     maxExecutions?: number;
+    /**
+     * How `price` reads. `total` (default) escrows one price for the whole
+     * engagement and pays at fulfillment; `per_task` is a RATE settled as each
+     * task completes (standing/open agreements only, and the default for a hire).
+     */
+    billing?: 'total' | 'per_task';
     agreementDescription?: string;
     parentAgreementId?: string;
     parentTaskId?: string;

package/dist/http/ConnectionsClient.d.ts

@@ -1,4 +1,5 @@
 import 'dotenv/config';
+import type { GrantView } from './grants.js';
 export declare function assertNoLeakedConnectionSecret(serialized: string): void;
 /** Thrown by ConnectionsClient with the HTTP status and raw body attached. */
 export interface ConnectionsError extends Error {
@@ -11,6 +12,23 @@ export interface ConnectionProxyParams {
     action: string;
     payload?: unknown;
 }
+/** A grant row from the per-connection lister (GET /connections/:id/grants). */
+export interface ConnectionGrant {
+    grantId?: string;
+    holderId?: string;
+    caveats?: unknown[];
+    [key: string]: unknown;
+}
+/**
+ * ZIG-641 / ZIG-648 — every connection grant the acting agent holds, grouped by
+ * connection, via the unified GET /grants. `provider` comes from the grant's
+ * resolved scope label.
+ */
+export interface ConnectionWithGrants {
+    connectionId: string;
+    provider: string | null;
+    grants: GrantView[];
+}
 export interface McpConnectionRequestParams {
     serverUrl: string;
     tools: string[];
@@ -53,7 +71,15 @@ export declare class ConnectionsClient {
      */
     listGrants({ connectionId }: {
         connectionId: string;
-    }): Promise<unknown[]>;
+    }): Promise<ConnectionGrant[]>;
+    /**
+     * ZIG-641 / ZIG-956 — cross-connection discovery over the unified GET /grants:
+     * every live connection grant this agent holds, grouped by connection, so a
+     * proxy caller's connectionId/grantId no longer has to arrive out of band.
+     * Moved here from ziggs-mcp's inline helper. The response is scanned
+     * defensively for leaked secrets, as `proxy` does.
+     */
+    listForHolder(): Promise<ConnectionWithGrants[]>;
     /** Issue a connection grant to an agent holder (connection owner side). */
     issueGrant({ connectionId, holderId, caveats, }: {
         connectionId: string;

package/dist/http/ConnectionsClient.js

@@ -1,6 +1,7 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
+import { GrantsClient } from './GrantsClient.js';
 // ZIG-569 — defense-in-depth mirror of the backend leak-guard
 // (assertProxyResponseDoesNotLeakTokens). The backend strips the *specific*
 // vault token from the response; clients never see that token, so this layer
@@ -82,6 +83,34 @@ export class ConnectionsClient {
         const grants = res['grants'] || [];
         return grants.filter((g) => g['holderId'] === this.agentId);
     }
+    /**
+     * ZIG-641 / ZIG-956 — cross-connection discovery over the unified GET /grants:
+     * every live connection grant this agent holds, grouped by connection, so a
+     * proxy caller's connectionId/grantId no longer has to arrive out of band.
+     * Moved here from ziggs-mcp's inline helper. The response is scanned
+     * defensively for leaked secrets, as `proxy` does.
+     */
+    async listForHolder() {
+        const grantsClient = new GrantsClient(this.operatorKey, this.agentId, this.baseUrl);
+        // All pages of the agent's live connection grants (not just the first page).
+        const items = await grantsClient.listAllGrants({
+            scopeKind: 'connection',
+            health: 'active',
+        });
+        const byConnection = new Map();
+        for (const g of items) {
+            const connectionId = g.scope.id;
+            let group = byConnection.get(connectionId);
+            if (!group) {
+                group = { connectionId, provider: g.scope.label ?? null, grants: [] };
+                byConnection.set(connectionId, group);
+            }
+            group.grants.push(g);
+        }
+        const result = [...byConnection.values()];
+        assertNoLeakedConnectionSecret(JSON.stringify(result));
+        return result;
+    }
     /** Issue a connection grant to an agent holder (connection owner side). */
     async issueGrant({ connectionId, holderId, caveats, }) {
         if (!connectionId)

package/dist/http/ContextReadClient.js

@@ -49,7 +49,13 @@ export class ContextReadClient {
         const res = await fetch(url.toString(), { headers });
         const body = await res.text().catch(() => '');
         if (!res.ok) {
-            throw new Error(`ContextReadClient.read ${type} ${res.status} ${body.slice(0, 200)}`);
+            // 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.
+            const err = new Error(`ContextReadClient.read ${type} ${res.status} ${body.slice(0, 200)}`);
+            err.status = res.status;
+            throw err;
         }
         return JSON.parse(body);
     }

package/dist/http/GrantsClient.d.ts

@@ -16,10 +16,26 @@ export interface ListGrantsQuery {
     cursor?: string;
     limit?: number;
 }
+/**
+ * ZIG-893 / ZIG-956 — a grant rail the caller's operator key cannot read, named
+ * by the backend on `GET /grants` (it silently drops those rails from `items`,
+ * so the unified list tool names what it isn't entitled to instead of
+ * presenting a short list as if it were complete). Replaces the client-side
+ * mirror of the backend scope table + JWT decode (the retired grantRails.ts).
+ */
+export interface UnreadableRail {
+    rail: 'context' | 'connection' | 'wallet';
+    requiredScope: string;
+}
 export interface ListGrantsResult {
     items: GrantView[];
     nextCursor: string | null;
     hasMore: boolean;
+    /**
+     * Rails the caller can't read, per the backend. Absent when the backend
+     * predates ZIG-956 or every requested rail was readable.
+     */
+    unreadableRails?: UnreadableRail[];
 }
 /**
  * ZIG-648 — unified grant listing across every rail. `GET /grants` returns the

package/dist/http/GrantsClient.js

@@ -48,6 +48,9 @@ export class GrantsClient {
             items: parsed.items ?? [],
             nextCursor: parsed.nextCursor ?? null,
             hasMore: parsed.hasMore ?? false,
+            ...(parsed.unreadableRails?.length
+                ? { unreadableRails: parsed.unreadableRails }
+                : {}),
         };
     }
     /**

package/dist/http/InboxClient.d.ts

@@ -1,28 +1,24 @@
 import 'dotenv/config';
-export type InboxScopeKind = 'chat' | 'agreement' | 'org';
 /**
- * ZIG-543: which chats a multi-chat scope's news is in. Lets a scope-granted
- * agent open the conversations behind the count (e.g. GET /chats/:chatId/messages).
+ * 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 InboxScopeChat {
-    chatId: string;
-    newMessages: number;
-    newArtifacts: number;
-    latestAt: string | null;
+export interface InboxDeliveryRef {
+    /** 'message' | 'artifact' | 'task-state' | 'agreement'. */
+    kind: string;
+    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;
 }
-export interface InboxScopeEntry {
-    scope: {
-        kind: InboxScopeKind;
-        id: string;
-    };
-    newMessages: number;
-    newArtifacts: number;
-    latestAt: string | null;
-    since: string;
-    /** Per-chat breakdown for org / agreement scopes (ZIG-543). Absent for a chat scope. */
-    chats?: InboxScopeChat[];
-    /** Chats with news beyond the per-scope cap, not listed in `chats`. */
-    truncatedChats?: number;
+/** 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;
@@ -35,54 +31,59 @@ export interface InboxConnectionRequestRef {
     message: string | null;
     requestedAt: string | null;
 }
-/** Agent asking its principal to connect an MCP server + grant tools (ZIG-686). */
-export interface InboxMcpServerRequestRef {
-    requestId: string;
-    requesterAgentId: string;
-    serverUrl: string;
-    tools: string[];
-    reason: string | null;
-    requestedAt: 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' | 'mcp_server_requests_awaiting_me' | 'multiple';
+    reason: 'proposals_awaiting_me' | 'connection_requests_awaiting_me' | 'multiple';
     proposalCount: number;
     truncatedProposals: number;
     connectionRequestCount: number;
     truncatedConnectionRequests: number;
-    mcpServerRequestCount: number;
-    truncatedMcpServerRequests: 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;
-    scopes: InboxScopeEntry[];
-    truncatedScopes: number;
-    countCap: number;
+    /**
+     * 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;
-    /** Agent requests to connect an MCP server awaiting the user (ZIG-686). */
-    mcpServerRequestsAwaitingMe: InboxMcpServerRequestRef[];
-    truncatedMcpServerRequests: number;
     humanAttention?: InboxHumanAttention;
 }
-export interface InboxAck {
-    kind: InboxScopeKind;
-    id: string;
-    upTo: string;
-}
 export interface InboxAckResult {
-    acked: Array<{
-        scope: {
-            kind: InboxScopeKind;
-            id: string;
-        };
-        ackedUpTo: string;
-    }>;
+    /** 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
@@ -93,27 +94,50 @@ 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 slice of the operator-level multiplexed read. */
+/**
+ * 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;
-    /** That agent's own inbox — fenced to its grants, floored by its cursors. */
-    inbox: InboxEnvelope;
+    /** 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: one poll across every agent the key's owner runs. */
+/** GET /inbox/operator: which of the key owner's agents have mail or open work. */
 export interface InboxOperatorEnvelope {
     asOf: string;
-    /** Agents with actionable content only. */
+    /** Agents with mail or open work. */
     agents: InboxOperatorAgentEntry[];
-    /** Agents examined whose inboxes were empty. */
+    /** 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 and counts since the
- * agent's last ack — never content. Flow: inbox → read → act → ack (ZIG-446).
- * Wraps `GET /inbox` and `POST /inbox/ack`.
+ * The doorbell, not the door (ZIG-434): references addressed to this agent
+ * since its last ack — never content. Flow: inbox → read → act → ack
+ * (ZIG-446). Wraps `GET /inbox` and `POST /inbox/ack`.
  */
 export declare class InboxClient {
     private readonly operatorKey;
@@ -128,11 +152,17 @@ export declare class InboxClient {
     private inboxUrl;
     getInbox(opts?: InboxReadOptions): Promise<InboxEnvelope>;
     /**
-     * Operator-level multiplexed read: one poll for every agent this key's
-     * owner runs, each slice fenced to its own agent (an agent-scoped key
-     * collapses to its one agent). Ack stays per agent — use a per-agent
-     * client's `ack()` after acting on that agent's slice.
+     * 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>;
-    ack(scopes: InboxAck[]): Promise<InboxAckResult>;
+    /**
+     * 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
+     * redeliver handled work.
+     */
+    ack(upTo: string): Promise<InboxAckResult>;
 }

package/dist/http/InboxClient.js

@@ -1,9 +1,9 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
 /**
- * The doorbell, not the door (ZIG-434): references and counts since the
- * agent's last ack — never content. Flow: inbox → read → act → ack (ZIG-446).
- * Wraps `GET /inbox` and `POST /inbox/ack`.
+ * The doorbell, not the door (ZIG-434): references addressed to this agent
+ * since its last ack — never content. Flow: inbox → read → act → ack
+ * (ZIG-446). Wraps `GET /inbox` and `POST /inbox/ack`.
  */
 export class InboxClient {
     operatorKey;
@@ -34,6 +34,9 @@ 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 = {}) {
@@ -47,28 +50,53 @@ export class InboxClient {
         return JSON.parse(body);
     }
     /**
-     * Operator-level multiplexed read: one poll for every agent this key's
-     * owner runs, each slice fenced to its own agent (an agent-scoped key
-     * collapses to its one agent). Ack stays per agent — use a per-agent
-     * client's `ack()` after acting on that agent's slice.
+     * 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 = {}) {
-        const res = await fetch(this.inboxUrl('/inbox/operator', opts), {
-            headers: this.headers(),
-        });
+        // 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 new Error(`InboxClient.getOperatorInbox ${res.status} ${body.slice(0, 200)}`);
         }
         return JSON.parse(body);
     }
-    async ack(scopes) {
-        if (!scopes.length)
-            throw new Error('InboxClient.ack: scopes are required');
+    /**
+     * 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
+     * redeliver handled work.
+     */
+    async ack(upTo) {
+        if (!upTo)
+            throw new Error('InboxClient.ack: upTo is required');
         const res = await fetch(`${this.baseUrl}/inbox/ack`, {
             method: 'POST',
             headers: this.headers(),
-            body: JSON.stringify({ scopes }),
+            body: JSON.stringify({ upTo }),
         });
         const body = await res.text().catch(() => '');
         if (!res.ok) {

package/dist/http/MarketplaceClient.d.ts

@@ -8,6 +8,12 @@ export interface PublishOfferPayload {
     maxExecutions?: number;
     /** `hire` = claimer becomes the provider's principal on claim. Defaults to `service` server-side. */
     engagementKind?: 'hire' | 'service';
+    /**
+     * How `price` reads. `total` (default) is one price for the whole engagement,
+     * escrowed on claim and paid at fulfillment; `per_task` is a RATE settled as
+     * each task completes (open/standing only; the default for a hire).
+     */
+    billing?: 'total' | 'per_task';
     /** Broadcast audience: 'everyone' (default, fully public) or 'org' (members of your active org only). */
     audience?: BroadcastAudience;
     metadata?: Record<string, unknown>;
@@ -20,6 +26,8 @@ export interface PullOffersOptions {
 export declare function pullOffers(options: PullOffersOptions | undefined, creds: Creds): Promise<Agreement[]>;
 export declare function claimOffer(agreementId: string, creds: Creds): Promise<Agreement>;
 export interface PublishQuestPayload {
+    /** See PublishOfferPayload.billing. */
+    billing?: 'total' | 'per_task';
     description: string;
     chatId?: string;
     payerId?: string;

package/dist/http/OrgsClient.d.ts

@@ -0,0 +1,36 @@
+import 'dotenv/config';
+import type { Creds } from '../types.js';
+export interface MyOrg {
+    orgId: string;
+    name: string;
+    kind: string;
+    role?: string;
+}
+/**
+ * ZIG-739 / ZIG-956 — the operator's full org membership (not just granted
+ * scopes, which is all the grant listers see). Lets a delegate resolve an org
+ * name to an id and offer a pick-list instead of demanding a pasted org_... id.
+ * Moved here from ziggs-mcp so every surface rides the one client (ZIG-894).
+ */
+export declare function fetchMyOrgs(creds: Creds, baseUrl?: string): Promise<MyOrg[]>;
+export type OrgResolution = {
+    status: 'ok';
+    orgId: string;
+} | {
+    status: 'ambiguous';
+    matches: MyOrg[];
+} | {
+    status: 'not-found';
+};
+/**
+ * ZIG-739 — resolve an org selector (exact org_... id OR a name/handle) against
+ * the operator's memberships. Exact id wins; otherwise case-insensitive name
+ * match. Ambiguous names return the candidates rather than guessing.
+ */
+export declare function resolveOrgSelector(orgs: MyOrg[], selector: string): OrgResolution;
+/**
+ * ZIG-640 / ZIG-956 — runtime acting org from the server (self-hire / agent
+ * row): GET /agents/claude-delegate/access. Moved here from ziggs-mcp's inline
+ * fetch (ZIG-894 "one client for every surface").
+ */
+export declare function fetchDelegateAccess(creds: Creds, baseUrl?: string): Promise<Record<string, unknown>>;