@ziggs-ai/api-client 0.10.4 → 0.12.0

package/dist/http/AgreementClient.d.ts

@@ -1,7 +1,7 @@
 import { type Creds, type Agreement, type EngagementKind, type BroadcastAudience } from '../types.js';
 /**
  * Shared proposal terms. When `engagementKind` is omitted the server defaults to `service`.
- * For an open buyer-broadcast quest, set `proposedTo` to a broadcast sentinel —
+ * For an open buyer-broadcast request, set `proposedTo` to a broadcast sentinel —
  * `OPEN_AGREEMENT_TARGET` (`"everyone"`, fully public) or `ORG_AGREEMENT_TARGET`
  * (`"org"`, scoped to your org). Prefer `proposeBroadcast({ audience })` over
  * setting `proposedTo` by hand.
@@ -79,7 +79,7 @@ export declare function proposeAgreement(proposalData: ProposeDirectInput, creds
 /** Propose a contract to one party (user or agent). Server defaults `engagementKind` to `service`. */
 export declare function proposeDirectTo(input: ProposeDirectInput, creds: Creds): Promise<Agreement>;
 /**
- * Propose an open quest. `audience` ('everyone' default | 'org') picks the
+ * Propose an open request. `audience` ('everyone' default | 'org') picks the
  * broadcast sentinel written to `proposedTo`. Server defaults `engagementKind`
  * to `service`.
  */
@@ -124,8 +124,12 @@ export declare function respondToAgreement(agreementId: string, action: 'approve
 export interface PendingApprovalFacts {
     /** Party ids with a pending entry on the approvals ledger. */
     pendingPartyIds: readonly string[];
-    /** The direct responder slot, when the proposal names one. */
-    proposedTo?: string | null;
+    /**
+     * The direct responder slot, when the proposal names one. A side names up to
+     * two ids — the accountable principal and the delegate acting for it — and
+     * either may be the one holding the decision.
+     */
+    proposedToIds?: readonly string[];
 }
 /**
  * Which of `candidateIds` holds the pending approval slot, first match wins —
@@ -146,7 +150,7 @@ export declare function resolveMyPendingApprovalPartyId(agreement: Agreement, op
  *
  * `partyId` MUST match the authenticated actor (`actor.id === partyId`): owner
  * principal when approving as human, delegate agent id when impersonating.
- * Canonical for hire, service, link, and quest proposals.
+ * Canonical for hire, service, link, and request proposals.
  */
 export declare function approveAgreementAsParty(agreementId: string, partyId: string, status: 'approved' | 'rejected', creds: Creds): Promise<Agreement>;
 export interface CounterAgreementData {
@@ -181,24 +185,42 @@ export interface GetMyAgreementsFilters {
 export declare function getMyAgreements(filters: GetMyAgreementsFilters | undefined, creds: Creds): Promise<Agreement[]>;
 /** One agreement, shaped: a link comes back as its summary. */
 export declare function getAgreement(agreementId: string, creds: Creds): Promise<Agreement | null>;
-export interface CreateAgreementBody {
-    proposedToId?: string;
-    providerId?: string;
-    agentId?: string;
-    price?: number;
-    lifecycle?: string;
-    expiresAt?: string;
-    maxExecutions?: number;
+export interface CreateLinkBody {
+    /**
+     * Who to connect with: an email address, or the id of an agent that answers
+     * to them. Either way the link is with the PERSON — an id is only a way to
+     * find its owner, and an agent that answers to an org is refused. Omit for an
+     * open invite you share yourself.
+     */
+    to?: string;
+    /** Message shown to whoever is asked to approve or claim it. */
     description?: string;
-    engagementKind?: EngagementKind;
-    /** Link invites only: how many people may claim this one link. Default 1. */
+    /** Open invites only: how many people may claim this one link. Default 1. */
     maxClaims?: number;
-    metadata?: Record<string, unknown>;
 }
-export declare function createAgreement(body: CreateAgreementBody, creds: Creds): Promise<{
+/**
+ * The route's one answer, whatever was in `to`.
+ *
+ * Deliberately carries no agreement. Returning the row for an id target and a
+ * bare "sent" for an address made one of the two an existence oracle over the
+ * user table, so both say the same thing now: it went. `shareUrl` is null
+ * exactly when `to` was named, which the caller already knows.
+ */
+export interface CreateLinkResult {
     ok: boolean;
-    agreement: Agreement;
-}>;
+    status: 'sent';
+    shareUrl: string | null;
+}
+/**
+ * Connect with someone — by email, by agent id, or with a shareable invite.
+ *
+ * This posts to `POST /agreements/links`. It used to post to `POST /agreements`,
+ * which also created work agreements inline and skipped the gates the proposal
+ * and marketplace paths run. Work agreements go through `proposeAgreement`
+ * (`POST /agreements/proposals`) and the marketplace claim routes; this rail
+ * carries links and nothing else.
+ */
+export declare function createLink(body: CreateLinkBody, creds: Creds): Promise<CreateLinkResult>;
 export declare function revokeAgreement(agreementId: string, creds: Creds): Promise<{
     ok: boolean;
     agreement: Agreement;
@@ -210,17 +232,34 @@ export declare function fulfillAgreement(agreementId: string, creds: Creds): Pro
     agreement: Agreement;
 }>;
 /** What an open-broadcast claim resolved to. ⚠️ Mirrors the server; it is authoritative. */
-export type ClaimedKind = 'link' | 'offer' | 'quest' | 'hand-off';
+export type ClaimedKind = 'link' | 'offer' | 'request' | 'hand-off';
 /**
  * Claim an open agreement. Three shapes are claimable:
  * - open link invite (`engagementKind: link`, proposedTo everyone)
- * - open broadcast quest (proposedTo 'everyone', status open)
- * - org-scoped broadcast quest (proposedTo 'org') — the server rejects the
+ * - open broadcast request (proposedTo 'everyone', status open)
+ * - org-scoped broadcast request (proposedTo 'org') — the server rejects the
  *   claim with 403 if the caller is not a member of the agreement's orgId
  *
  * POST /agreements/:id/claim — canonical; no partyId in body.
  */
-export declare function claimAgreement(agreementId: string, creds: Creds): Promise<{
+/**
+ * What a claimer can say about WHY it is claiming.
+ *
+ * A claim binds a party to terms somebody else posted, so the only thing there
+ * is to declare is the authority behind it: the job the claiming agent is
+ * already doing. Nothing here changes the row — the lineage of a posted
+ * agreement belongs to whoever posted it.
+ */
+export interface ClaimOptions {
+    /**
+     * The active agreement whose work this claim is part of. An agent acting
+     * inside a job its human approved does not need a second consent for the
+     * engagements that job requires, but it has to NAME the job — the server
+     * verifies the claim against the acting agent and never guesses one.
+     */
+    mandateAgreementId?: string;
+}
+export declare function claimAgreement(agreementId: string, creds: Creds, opts?: ClaimOptions): Promise<{
     ok: boolean;
     agreement: Agreement;
     kind?: ClaimedKind;
@@ -262,10 +301,7 @@ export declare class AgreementClient {
     list(filters?: ListAgreementsFilters): Promise<Agreement[]>;
     listMine(filters?: GetMyAgreementsFilters): Promise<Agreement[]>;
     get(id: string): Promise<Agreement | null>;
-    create(data: CreateAgreementBody): Promise<{
-        ok: boolean;
-        agreement: Agreement;
-    }>;
+    createLink(data: CreateLinkBody): Promise<CreateLinkResult>;
     revoke(id: string): Promise<{
         ok: boolean;
         agreement: Agreement;

package/dist/http/AgreementClient.js

@@ -1,6 +1,6 @@
 import { runtimeLog } from '../shared/runtimeLog.js';
 import { getBackendUrl } from '../utils/urlUtils.js';
-import { OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET, isBroadcastTarget } from '../types.js';
+import { OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET, isBroadcastTarget, partySideIds } from '../types.js';
 import { throwApiError } from '../shared/apiError.js';
 // Lazy: read at call time so a `configureApiClient` call that lands after this
 // module is imported still takes effect. Baking it at module-load time would
@@ -37,6 +37,10 @@ function assertCreds(creds, op) {
  * unchanged.
  */
 export function linkSummary(a) {
+    const side = (s) => ({
+        principal: s?.principal ?? null,
+        actor: s?.actor ?? null,
+    });
     return {
         agreementId: a.agreementId,
         // Kept deliberately: callers branch on this, and a summary that hides what
@@ -44,11 +48,11 @@ export function linkSummary(a) {
         engagementKind: a.engagementKind,
         status: a.status,
         proposalStatus: a.proposalStatus,
+        // No `payer`: a link carries no money, so the paying side is never occupied.
         parties: {
-            creatorAgent: a.parties?.creatorAgent ?? null,
-            providerAgent: a.parties?.providerAgent ?? null,
-            creator: a.parties?.creator ?? null,
-            proposedTo: a.parties?.proposedTo ?? null,
+            creator: side(a.parties?.creator),
+            provider: side(a.parties?.provider),
+            proposedTo: side(a.parties?.proposedTo),
         },
         ...(a.description ? { description: a.description } : {}),
         // Seat bookkeeping on an open invite — link state, not commerce.
@@ -103,7 +107,7 @@ export async function proposeDirectTo(input, creds) {
     return proposeAgreement(input, creds);
 }
 /**
- * Propose an open quest. `audience` ('everyone' default | 'org') picks the
+ * Propose an open request. `audience` ('everyone' default | 'org') picks the
  * broadcast sentinel written to `proposedTo`. Server defaults `engagementKind`
  * to `service`.
  */
@@ -169,10 +173,10 @@ export async function respondToAgreement(agreementId, action, creds, opts = {})
         ownerUserId: opts.ownerUserId,
         agentId: creds.agentId,
     });
-    const proposedTo = agreement.parties?.proposedTo;
-    if (isBroadcastTarget(proposedTo) || isBroadcastTarget(agreement.parties?.payer)) {
+    const proposedTo = agreement.parties?.proposedTo?.principal;
+    if (isBroadcastTarget(proposedTo) || isBroadcastTarget(agreement.parties?.payer?.principal)) {
         // respond is approve/reject on DIRECT proposals only. An open
-        // broadcast (quest, standing offer, link invite) has no per-recipient
+        // broadcast (request, standing offer, link invite) has no per-recipient
         // approval slot — a BYSTANDER can neither approve nor reject it
         //; their move is to claim it, which has its own verb.
         //
@@ -206,11 +210,12 @@ export function resolvePendingApprovalPartyId(facts, candidateIds) {
     }
     // A row with no pending ledger entries is a legacy one (approvals[] predates
     //), and there the named responder slot IS the decision.
-    const proposedTo = facts.proposedTo ?? null;
-    if (proposedTo &&
-        actorIds.includes(proposedTo) &&
-        facts.pendingPartyIds.length === 0) {
-        return proposedTo;
+    if (facts.pendingPartyIds.length === 0) {
+        const responderIds = facts.proposedToIds ?? [];
+        for (const id of actorIds) {
+            if (responderIds.includes(id))
+                return id;
+        }
     }
     return null;
 }
@@ -223,7 +228,7 @@ export function resolveMyPendingApprovalPartyId(agreement, opts) {
         pendingPartyIds: (agreement.approvals ?? [])
             .filter((a) => a.status === 'pending' || a.status === 'PENDING')
             .map((a) => a.partyId),
-        proposedTo: agreement.parties?.proposedTo ?? null,
+        proposedToIds: partySideIds(agreement.parties?.proposedTo),
     }, [opts.agentId, opts.ownerUserId]);
 }
 /**
@@ -232,7 +237,7 @@ export function resolveMyPendingApprovalPartyId(agreement, opts) {
  *
  * `partyId` MUST match the authenticated actor (`actor.id === partyId`): owner
  * principal when approving as human, delegate agent id when impersonating.
- * Canonical for hire, service, link, and quest proposals.
+ * Canonical for hire, service, link, and request proposals.
  */
 export async function approveAgreementAsParty(agreementId, partyId, status, creds) {
     if (!agreementId)
@@ -406,26 +411,38 @@ export async function getAgreement(agreementId, creds) {
     const agreement = await getAgreementDocument(agreementId, creds);
     return agreement ? shapeAgreement(agreement) : null;
 }
-export async function createAgreement(body, creds) {
+/**
+ * Connect with someone — by email, by agent id, or with a shareable invite.
+ *
+ * This posts to `POST /agreements/links`. It used to post to `POST /agreements`,
+ * which also created work agreements inline and skipped the gates the proposal
+ * and marketplace paths run. Work agreements go through `proposeAgreement`
+ * (`POST /agreements/proposals`) and the marketplace claim routes; this rail
+ * carries links and nothing else.
+ */
+export async function createLink(body, creds) {
     if (!body)
-        throw new Error('Body is required for agreement creation');
-    assertCreds(creds, 'agreement creation');
-    // Canonical REST create: POST /agreements.
-    const res = await fetch(getAgreementBaseUrl(), {
+        throw new Error('Body is required for link creation');
+    assertCreds(creds, 'link creation');
+    const res = await fetch(`${getAgreementBaseUrl()}/links`, {
         method: 'POST',
         headers: buildHeaders(creds),
         body: JSON.stringify(body),
     });
     if (!res.ok) {
         const responseBody = await res.text().catch(() => '');
-        throwApiError(res, responseBody, `Agreement creation failed: ${res.status} ${res.statusText}`);
+        throwApiError(res, responseBody, `Link creation failed: ${res.status} ${res.statusText}`);
     }
     const data = await res.json().catch(() => null);
-    if (!data?.['agreement']) {
-        throw new Error('Invalid response: expected { ok, agreement } from POST /agreements');
+    if (data?.['status'] !== 'sent') {
+        throw new Error('Invalid response: expected { ok, status: "sent", shareUrl } from POST /agreements/links');
     }
-    const envelope = data;
-    return { ...envelope, agreement: shapeAgreement(envelope.agreement) };
+    const shareUrl = data['shareUrl'];
+    return {
+        ok: data['ok'] === true,
+        status: 'sent',
+        shareUrl: typeof shareUrl === 'string' ? shareUrl : null,
+    };
 }
 export async function revokeAgreement(agreementId, creds) {
     if (!agreementId)
@@ -469,20 +486,15 @@ export async function fulfillAgreement(agreementId, creds) {
     const envelope = data;
     return { ...envelope, agreement: shapeAgreement(envelope.agreement) };
 }
-/**
- * Claim an open agreement. Three shapes are claimable:
- * - open link invite (`engagementKind: link`, proposedTo everyone)
- * - open broadcast quest (proposedTo 'everyone', status open)
- * - org-scoped broadcast quest (proposedTo 'org') — the server rejects the
- *   claim with 403 if the caller is not a member of the agreement's orgId
- *
- * POST /agreements/:id/claim — canonical; no partyId in body.
- */
-export async function claimAgreement(agreementId, creds) {
+export async function claimAgreement(agreementId, creds, opts = {}) {
     if (!agreementId)
         throw new Error('agreementId is required to claim an open agreement');
     assertCreds(creds, 'open agreement claim');
-    const res = await fetch(`${getAgreementBaseUrl()}/${encodeURIComponent(agreementId)}/claim`, { method: 'POST', headers: buildHeaders(creds) });
+    const res = await fetch(`${getAgreementBaseUrl()}/${encodeURIComponent(agreementId)}/claim`, {
+        method: 'POST',
+        headers: buildHeaders(creds),
+        body: JSON.stringify(opts.mandateAgreementId ? { mandateAgreementId: opts.mandateAgreementId } : {}),
+    });
     if (!res.ok) {
         const body = await res.text().catch(() => '');
         throwApiError(res, body, `Open agreement claim failed: ${res.status} ${res.statusText}`);
@@ -493,7 +505,7 @@ export async function claimAgreement(agreementId, creds) {
     }
     // 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
+    // and a request (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) };
@@ -683,7 +695,7 @@ export class AgreementClient {
     list(filters) { return listAgreements(filters, this.creds); }
     listMine(filters) { return getMyAgreements(filters, this.creds); }
     get(id) { return getAgreement(id, this.creds); }
-    create(data) { return createAgreement(data, this.creds); }
+    createLink(data) { return createLink(data, this.creds); }
     revoke(id) { return revokeAgreement(id, this.creds); }
     fulfill(id) { return fulfillAgreement(id, this.creds); }
     claimAgreement(id) { return claimAgreement(id, this.creds); }

package/dist/http/ChatClient.d.ts

@@ -21,6 +21,7 @@ export interface SendChatMessageInput {
      * Recipient id. Optional: when omitted, the backend infers the
      * receiver if the chat has exactly one other member (one agent, or one
      * other human). Provide it explicitly in chats with multiple members.
+     * Sent on the wire as `{ id }`; the SDK still takes a string.
      */
     receiverId?: string;
     text: string;

package/dist/http/ChatClient.js

@@ -93,7 +93,10 @@ export async function sendChatMessage(input, creds) {
             text: input.text,
             entryType,
             contentType,
-            receiver: input.receiverId,
+            // Canonical wire shape is `{ id, type? }`; bare strings are still
+            // accepted by the backend after edge normalize, but first-party
+            // clients send the object.
+            receiver: input.receiverId ? { id: input.receiverId } : undefined,
             underAgreementId: input.underAgreementId,
         }),
     });

package/dist/http/ConnectionsClient.js

@@ -93,10 +93,21 @@ export class ConnectionsClient {
     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({
+        const { items, unreadableRails } = await grantsClient.listAllGrantsWithRails({
             scopeKind: 'connection',
             health: 'active',
         });
+        // An unreadable rail is not an empty one. Returning [] here made
+        // every caller say "no connection grant" when the truth was "this key may not
+        // look" — the needs gate refused work the agent could do, and the MCP tool
+        // told the owner to issue a grant that already existed. Throwing puts the
+        // missing scope in the message, where the person who can fix it will read it.
+        const railBlocked = unreadableRails.find((r) => r.rail === 'connection');
+        if (railBlocked && items.length === 0) {
+            throw new Error(`Cannot read this agent's connection grants: the operator key is missing the ` +
+                `"${railBlocked.requiredScope}" scope, so the grant list came back empty whether or not ` +
+                'a grant exists. Re-mint the key with that scope (the "launcher-mcp-broker" preset includes it).');
+        }
         const byConnection = new Map();
         for (const g of items) {
             const connectionId = g.scope.id;

package/dist/http/ContextGrantsClient.d.ts

@@ -1,4 +1,4 @@
-import type { GrantView } from './grants.js';
+import type { GrantAccessKind, GrantHolderKind, GrantView } from './grants.js';
 /**
  * added `artifact` — the narrowest context scope: one specific artifact,
  * shared without sharing any chat or agreement it sits in. Still the context
@@ -21,12 +21,26 @@ export interface ContextGrantScope {
 export type ContextGrantRecord = GrantView;
 export interface IssueContextGrantInput {
     holderId: string;
+    /**
+     * What kind of principal the holder is: a person, an organization, or an
+     * agent. Always stated, because an id says nothing about what it names — and
+     * an organization holder is how one grant covers a whole team.
+     */
+    holderKind: GrantHolderKind;
+    /**
+     * What the holder may do: `read` to see the scope, `write` to take part in
+     * it, `admit` to bring others in as well. Defaults to `write`.
+     */
+    kind?: GrantAccessKind;
     scope: ContextGrantScope;
     temporal?: ContextTemporal;
     expiresAt?: string | null;
 }
 export interface DelegateContextGrantInput {
     holderId: string;
+    holderKind: GrantHolderKind;
+    /** Never stronger than the grant it comes from; defaults to the same. */
+    kind?: GrantAccessKind;
     scope: ContextGrantScope;
     temporal: ContextTemporal;
     expiresAt?: string | null;

package/dist/http/ContextGrantsClient.js

@@ -28,6 +28,8 @@ export class ContextGrantsClient {
             }),
             body: JSON.stringify({
                 holderId: input.holderId,
+                holderKind: input.holderKind,
+                kind: input.kind,
                 scope: input.scope,
                 temporal: input.temporal,
                 expiresAt: input.expiresAt,

package/dist/http/ContextReadClient.d.ts

@@ -43,17 +43,26 @@ export interface ContextReadEnvelope<T = unknown> {
     latestSequence?: string | null;
 }
 /** Aggregated chat snapshot from `GET /context/snapshot` (follow-up). */
+/**
+ * One participant on the snapshot roster. `kind` is the declared holder kind the
+ * server stamped on the row, so a reader takes what a participant IS from the
+ * row rather than from which array it arrived in. Optional so a backend that
+ * predates it still parses.
+ */
+export interface ContextSnapshotParticipant {
+    role: string;
+    kind?: string;
+    isYou?: boolean;
+    [key: string]: unknown;
+}
 export interface ContextSnapshotResult {
     history: unknown[];
     agreements: unknown[];
-    agents: Array<{
+    agents: Array<ContextSnapshotParticipant & {
         agentId: string;
-        role: string;
-        isYou: boolean;
     }>;
-    users: Array<{
+    users: Array<ContextSnapshotParticipant & {
         userId: string;
-        role: string;
     }>;
     latestSequence?: string | null;
     chatMissing?: boolean;

package/dist/http/GrantsClient.d.ts

@@ -66,4 +66,18 @@ export declare class GrantsClient {
      * truncated. `maxPages` bounds the loop as a runaway guard.
      */
     listAllGrants(query?: Omit<ListGrantsQuery, 'cursor'>, maxPages?: number): Promise<GrantView[]>;
+    /**
+     * The same sweep, keeping the part `listAllGrants` throws away: which rails the
+     * caller was not allowed to read.
+     *
+     * The distinction is not cosmetic. An empty page from an unreadable rail looks
+     * exactly like "you hold no grants", and a caller that cannot tell them apart
+     * reports the wrong one: a brokered connector agent with a live grant refused
+     * its task and told the buyer to ask for the grant they had just issued, because
+     * its key lacked `connections:read` and this method answered "none".
+     */
+    listAllGrantsWithRails(query?: Omit<ListGrantsQuery, 'cursor'>, maxPages?: number): Promise<{
+        items: GrantView[];
+        unreadableRails: UnreadableRail[];
+    }>;
 }

package/dist/http/GrantsClient.js

@@ -65,15 +65,31 @@ export class GrantsClient {
      * truncated. `maxPages` bounds the loop as a runaway guard.
      */
     async listAllGrants(query = {}, maxPages = 50) {
+        return (await this.listAllGrantsWithRails(query, maxPages)).items;
+    }
+    /**
+     * The same sweep, keeping the part `listAllGrants` throws away: which rails the
+     * caller was not allowed to read.
+     *
+     * The distinction is not cosmetic. An empty page from an unreadable rail looks
+     * exactly like "you hold no grants", and a caller that cannot tell them apart
+     * reports the wrong one: a brokered connector agent with a live grant refused
+     * its task and told the buyer to ask for the grant they had just issued, because
+     * its key lacked `connections:read` and this method answered "none".
+     */
+    async listAllGrantsWithRails(query = {}, maxPages = 50) {
         const all = [];
+        const rails = new Map();
         let cursor;
         for (let page = 0; page < maxPages; page++) {
             const res = await this.listGrants({ ...query, cursor });
             all.push(...res.items);
+            for (const rail of res.unreadableRails ?? [])
+                rails.set(rail.rail, rail);
             if (!res.nextCursor)
-                return all;
+                break;
             cursor = res.nextCursor;
         }
-        return all;
+        return { items: all, unreadableRails: [...rails.values()] };
     }
 }

package/dist/http/InboxClient.js

@@ -1,5 +1,6 @@
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { pollSurfaceError } from '../shared/rateLimit.js';
+import { INBOX_HOST_CLAIMANT_HEADER, instanceIdentity, } from '../instanceIdentity.js';
 /**
  * The doorbell, not the door: references addressed to this agent
  * since its last ack — never content. Flow: inbox → read → act → ack
@@ -24,6 +25,9 @@ export class InboxClient {
         const headers = {
             Authorization: `Bearer ${this.operatorKey}`,
             'Content-Type': 'application/json',
+            // This process, not the API. Two fleets of the same agent share
+            // one backend task; without this they both wake.
+            [INBOX_HOST_CLAIMANT_HEADER]: instanceIdentity(),
         };
         if (this.agentId)
             headers['X-Agent-Id'] = this.agentId;

package/dist/http/MarketplaceClient.d.ts

@@ -23,8 +23,7 @@ export interface PullOffersOptions {
     since?: string;
 }
 export declare function pullOffers(options: PullOffersOptions | undefined, creds: Creds): Promise<Agreement[]>;
-export declare function claimOffer(agreementId: string, creds: Creds): Promise<Agreement>;
-export interface PublishQuestPayload {
+export interface PublishRequestPayload {
     /** See PublishOfferPayload.billing. */
     billing?: 'total' | 'per_task';
     description: string;
@@ -38,12 +37,12 @@ export interface PublishQuestPayload {
     /** Broadcast audience: 'everyone' (default, fully public) or 'org' (members of your active org only). */
     audience?: BroadcastAudience;
 }
-export declare function publishQuest(payload: PublishQuestPayload, creds: Creds): Promise<Agreement>;
-export interface PullQuestsOptions {
+export declare function publishRequest(payload: PublishRequestPayload, creds: Creds): Promise<Agreement>;
+export interface PullRequestsOptions {
     limit?: number;
     since?: string;
 }
-export declare function pullQuests(options: PullQuestsOptions | undefined, creds: Creds): Promise<Agreement[]>;
+export declare function pullRequests(options: PullRequestsOptions | undefined, creds: Creds): Promise<Agreement[]>;
 export declare class MarketplaceClient {
     private creds;
     /**
@@ -53,7 +52,6 @@ export declare class MarketplaceClient {
     constructor(operatorKey: string, agentId?: string);
     publishOffer(payload: PublishOfferPayload): Promise<Agreement>;
     pullOffers(options?: PullOffersOptions): Promise<Agreement[]>;
-    claimOffer(agreementId: string): Promise<Agreement>;
-    publishQuest(payload: PublishQuestPayload): Promise<Agreement>;
-    pullQuests(options?: PullQuestsOptions): Promise<Agreement[]>;
+    publishRequest(payload: PublishRequestPayload): Promise<Agreement>;
+    pullRequests(options?: PullRequestsOptions): Promise<Agreement[]>;
 }

package/dist/http/MarketplaceClient.js

@@ -52,55 +52,37 @@ export async function pullOffers(options, creds) {
     const data = await res.json().catch(() => null);
     return data?.['offers'] ?? [];
 }
-export async function claimOffer(agreementId, creds) {
-    if (!agreementId)
-        throw new Error('agreementId is required');
-    assertCreds(creds, 'marketplace offer claim');
-    const res = await fetch(`${getMarketplaceBaseUrl()}/offers/claim`, {
-        method: 'POST',
-        headers: buildHeaders(creds),
-        body: JSON.stringify({ agreementId }),
-    });
-    if (!res.ok) {
-        const body = await res.text().catch(() => '');
-        throwApiError(res, body, `Marketplace offer claim failed: ${res.status}`);
-    }
-    const data = await res.json().catch(() => null);
-    if (!data?.['ok'])
-        throw new Error(data?.['error'] || 'Claim failed');
-    return shapeAgreement(data['offer']);
-}
-export async function publishQuest(payload, creds) {
-    assertCreds(creds, 'quest publish');
-    const res = await fetch(`${getMarketplaceBaseUrl()}/quests/publish`, {
+export async function publishRequest(payload, creds) {
+    assertCreds(creds, 'request publish');
+    const res = await fetch(`${getMarketplaceBaseUrl()}/requests/publish`, {
         method: 'POST',
         headers: buildHeaders(creds),
         body: JSON.stringify(payload || {}),
     });
     if (!res.ok) {
         const body = await res.text().catch(() => '');
-        throwApiError(res, body, `Quest publish failed: ${res.status}`);
+        throwApiError(res, body, `Request publish failed: ${res.status}`);
     }
     const data = await res.json().catch(() => null);
     if (!data?.['agreement'])
-        throw new Error('Quest publish returned no agreement');
+        throw new Error('Request publish returned no agreement');
     return shapeAgreement(data['agreement']);
 }
-export async function pullQuests(options, creds) {
-    assertCreds(creds, 'quest pull');
+export async function pullRequests(options, creds) {
+    assertCreds(creds, 'request pull');
     const params = new URLSearchParams();
     if (options?.limit != null)
         params.set('limit', String(options.limit));
     if (options?.since)
         params.set('since', options.since);
     const qs = params.toString();
-    const res = await fetch(`${getMarketplaceBaseUrl()}/quests${qs ? `?${qs}` : ''}`, {
+    const res = await fetch(`${getMarketplaceBaseUrl()}/requests${qs ? `?${qs}` : ''}`, {
         method: 'GET',
         headers: buildHeaders(creds),
     });
     if (!res.ok) {
         const body = await res.text().catch(() => '');
-        throwApiError(res, body, `Quest pull failed: ${res.status}`);
+        throwApiError(res, body, `Request pull failed: ${res.status}`);
     }
     const data = await res.json().catch(() => null);
     return data?.['agreements'] ?? [];
@@ -120,7 +102,6 @@ export class MarketplaceClient {
     }
     publishOffer(payload) { return publishOffer(payload, this.creds); }
     pullOffers(options) { return pullOffers(options, this.creds); }
-    claimOffer(agreementId) { return claimOffer(agreementId, this.creds); }
-    publishQuest(payload) { return publishQuest(payload, this.creds); }
-    pullQuests(options) { return pullQuests(options, this.creds); }
+    publishRequest(payload) { return publishRequest(payload, this.creds); }
+    pullRequests(options) { return pullRequests(options, this.creds); }
 }

package/dist/http/TaskClient.d.ts

@@ -86,6 +86,11 @@ export interface ListTasksOptions {
     limit?: number;
     /** Filter to tasks assigned to this id. */
     assignedTo?: string;
+    /**
+     * Filter to tasks CREATED by this id — what the caller handed out, as
+     * opposed to what was handed to it.
+     */
+    createdBy?: string;
 }
 export interface ListTasksResult {
     tasks: Task[];