@ziggs-ai/api-client 0.11.0 → 0.13.0

package/dist/capabilities/nextCall.js

@@ -14,19 +14,65 @@ export function nextCall(env, capabilityKey, args, why) {
     };
 }
 /**
- * The other party in a two-party agreement, from the perspective of `selfId`.
+ * The other PRINCIPAL in a two-party agreement, from the perspective of
+ * `selfId`.
+ *
+ * This was `peerAgentId`, and it read the `actor` columns — the agents that
+ * carried the paperwork. Those became courier info when a link was re-keyed to
+ * the two people it belongs to, and on most links they are null, so the hint it
+ * fed either pre-filled a call with an agent that is no longer a door or
+ * silently vanished because the helper returned nothing.
+ *
+ * Named for the SLOT, not for what a link happens to put in it. On a link both
+ * principals are guaranteed to be people, because links are person-only and
+ * both sides are userIds by construction — but the same slots hold an org or an
+ * agent on other engagement kinds, so a caller who read "person" here and
+ * trusted it on a hire would be wrong. The person guarantee is a link-only
+ * property; ask the kind before relying on it.
  *
  * Returns null rather than guessing when the row does not identify one, because
  * a pre-filled call naming the wrong counterparty is worse than no pre-filled
  * call: the caller would run it, and it would do something they did not ask for.
  */
-export function peerAgentId(parties, selfId) {
+export function peerPrincipalId(parties, selfId) {
     if (!parties || !selfId)
         return null;
-    const { creatorAgent, providerAgent } = parties;
-    if (creatorAgent && creatorAgent !== selfId)
-        return creatorAgent;
-    if (providerAgent && providerAgent !== selfId)
-        return providerAgent;
+    const creator = parties.creator?.principal;
+    const provider = parties.provider?.principal;
+    if (creator && creator !== selfId)
+        return creator;
+    if (provider && provider !== selfId)
+        return provider;
     return null;
 }
+/**
+ * The peer's principal, located by finding MY side rather than by knowing my
+ * own principal id.
+ *
+ * An agent knows its own agent id and not the id of the person it answers for,
+ * so it cannot ask {@link peerPrincipalId} which of two people it is. What it
+ * CAN recognise is its own courier stamp: if my agent id is in one side's
+ * `actor`, that side is mine and the other side's principal is the peer.
+ *
+ * Note the difference from the bug this replaced. Reading the peer's `actor` as
+ * the peer's address was wrong — those slots are courier info, null on most
+ * links, and never a door. Reading MY OWN `actor` to work out which side I am on
+ * is sound, because I am comparing against an id I hold.
+ *
+ * Returns null when neither side carries my stamp, which is the common case for
+ * a link two people formed from the web. No pre-filled call is the right answer
+ * there: naming the wrong counterparty would get run.
+ */
+export function peerPrincipalForCourier(parties, myAgentId) {
+    if (!parties || !myAgentId)
+        return null;
+    const mineIsCreator = parties.creator?.actor === myAgentId;
+    const mineIsProvider = parties.provider?.actor === myAgentId;
+    // Both sides stamped with me is one estate on both ends, not a peer.
+    if (mineIsCreator === mineIsProvider)
+        return null;
+    const peer = mineIsCreator
+        ? parties.provider?.principal
+        : parties.creator?.principal;
+    return peer && peer !== myAgentId ? peer : null;
+}

package/dist/http/AgreementClient.d.ts

@@ -44,6 +44,12 @@ export interface ProposeDirectInput extends ProposeTerms {
  */
 export type ProposeBroadcastInput = Omit<ProposeDirectInput, 'proposedTo'> & {
     audience?: BroadcastAudience;
+    /**
+     * Exact-match triage for supplier hosts: a plain string they compare
+     * verbatim, no LLM turn. Absent or empty still delivers the request; the
+     * supplier just has nothing to triage on.
+     */
+    match?: string;
 };
 /**
  * A trust link's agreement, as every caller sees it.
@@ -124,8 +130,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 —
@@ -182,17 +192,33 @@ export declare function getMyAgreements(filters: GetMyAgreementsFilters | undefi
 /** One agreement, shaped: a link comes back as its summary. */
 export declare function getAgreement(agreementId: string, creds: Creds): Promise<Agreement | null>;
 export interface CreateLinkBody {
-    /** Target agent for a direct link. Omit for an open, claimable invite. */
-    targetAgentId?: string;
+    /**
+     * 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;
     /** Open invites only: how many people may claim this one link. Default 1. */
     maxClaims?: number;
-    /** Which of the caller's own agents stands on their side of the link. */
-    asAgentId?: string;
 }
 /**
- * Create a trust link — a direct proposal to one agent, or an open invite.
+ * 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;
+    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
@@ -200,10 +226,7 @@ export interface CreateLinkBody {
  * (`POST /agreements/proposals`) and the marketplace claim routes; this rail
  * carries links and nothing else.
  */
-export declare function createLink(body: CreateLinkBody, creds: Creds): Promise<{
-    ok: boolean;
-    agreement: Agreement;
-}>;
+export declare function createLink(body: CreateLinkBody, creds: Creds): Promise<CreateLinkResult>;
 export declare function revokeAgreement(agreementId: string, creds: Creds): Promise<{
     ok: boolean;
     agreement: Agreement;
@@ -225,19 +248,33 @@ export type ClaimedKind = 'link' | 'offer' | 'request' | 'hand-off';
  *
  * 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;
 }>;
 /**
- * Link types a caller may ASK for — the server's `CALLER_LINK_TYPES`, not its
- * full `LINK_TYPES`. `space` is deliberately absent: an agreement space gets
- * exactly one system-minted room, and letting a request name that type would
- * burn the root's single slot on an unrelated chat. Shorter than the server
- * union on purpose, which is why this list carries the reason with it.
+ * Link types a caller may ask for. `origin` and `delegation` are workflow-owned;
+ * callers may only pin an agreement into a chat as a reference (`mention`).
  */
-export declare const CHAT_LINK_TYPES: readonly ["origin", "mention", "delegation", "join"];
+export declare const CHAT_LINK_TYPES: readonly ["mention"];
 export type ChatLinkType = (typeof CHAT_LINK_TYPES)[number];
 export declare function linkAgreementToChat(agreementId: string, chatId: string, linkType: ChatLinkType | undefined, creds: Creds): Promise<unknown | null>;
 export declare function getChatsForAgreement(agreementId: string, creds: Creds): Promise<unknown[]>;
@@ -245,10 +282,6 @@ export declare const ARTIFACT_LINK_TYPES: readonly ["produced", "referenced"];
 export type ArtifactLinkType = (typeof ARTIFACT_LINK_TYPES)[number];
 export declare function linkArtifactToAgreement(agreementId: string, artifactId: string, linkType: ArtifactLinkType | undefined, creds: Creds): Promise<unknown | null>;
 export declare function getArtifactsForAgreement(agreementId: string, creds: Creds): Promise<unknown[]>;
-export declare const AGREEMENT_USER_ROLES: readonly ["payer", "provider", "participant", "observer"];
-export type UserRole = (typeof AGREEMENT_USER_ROLES)[number];
-export declare function linkUserToAgreement(agreementId: string, userId: string, role: UserRole, creds: Creds): Promise<unknown | null>;
-export declare function getUsersForAgreement(agreementId: string, creds: Creds): Promise<unknown[]>;
 export declare class AgreementClient {
     private creds;
     /**
@@ -267,10 +300,7 @@ export declare class AgreementClient {
     list(filters?: ListAgreementsFilters): Promise<Agreement[]>;
     listMine(filters?: GetMyAgreementsFilters): Promise<Agreement[]>;
     get(id: string): Promise<Agreement | null>;
-    createLink(data: CreateLinkBody): Promise<{
-        ok: boolean;
-        agreement: Agreement;
-    }>;
+    createLink(data: CreateLinkBody): Promise<CreateLinkResult>;
     revoke(id: string): Promise<{
         ok: boolean;
         agreement: Agreement;
@@ -288,6 +318,4 @@ export declare class AgreementClient {
     listChats(id: string): Promise<unknown[]>;
     linkArtifact(id: string, artifactId: string, linkType?: ArtifactLinkType): Promise<unknown>;
     listArtifacts(id: string): Promise<unknown[]>;
-    linkUser(id: string, userId: string, role: UserRole): Promise<unknown>;
-    listUsers(id: string): Promise<unknown[]>;
 }

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.
@@ -169,8 +173,8 @@ 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 (request, standing offer, link invite) has no per-recipient
         // approval slot — a BYSTANDER can neither approve nor reject it
@@ -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]);
 }
 /**
@@ -407,7 +412,7 @@ export async function getAgreement(agreementId, creds) {
     return agreement ? shapeAgreement(agreement) : null;
 }
 /**
- * Create a trust link — a direct proposal to one agent, or an open invite.
+ * 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
@@ -429,11 +434,15 @@ export async function createLink(body, creds) {
         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/links');
+    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)
@@ -477,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 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 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}`);
@@ -510,18 +514,10 @@ export async function claimAgreement(agreementId, creds) {
 // Chat links
 // ---------------------------------------------------------------------------
 /**
- * Link types a caller may ASK for — the server's `CALLER_LINK_TYPES`, not its
- * full `LINK_TYPES`. `space` is deliberately absent: an agreement space gets
- * exactly one system-minted room, and letting a request name that type would
- * burn the root's single slot on an unrelated chat. Shorter than the server
- * union on purpose, which is why this list carries the reason with it.
+ * Link types a caller may ask for. `origin` and `delegation` are workflow-owned;
+ * callers may only pin an agreement into a chat as a reference (`mention`).
  */
-export const CHAT_LINK_TYPES = [
-    'origin',
-    'mention',
-    'delegation',
-    'join',
-];
+export const CHAT_LINK_TYPES = ['mention'];
 export async function linkAgreementToChat(agreementId, chatId, linkType = 'mention', creds) {
     if (!agreementId || !chatId)
         return null;
@@ -614,59 +610,6 @@ export async function getArtifactsForAgreement(agreementId, creds) {
         return [];
     }
 }
-// ---------------------------------------------------------------------------
-// User links
-// ---------------------------------------------------------------------------
-export const AGREEMENT_USER_ROLES = [
-    'payer',
-    'provider',
-    'participant',
-    'observer',
-];
-export async function linkUserToAgreement(agreementId, userId, role, creds) {
-    if (!agreementId || !userId || !role)
-        return null;
-    assertCreds(creds, 'link user to agreement');
-    try {
-        const res = await fetch(`${getAgreementBaseUrl()}/${agreementId}/users`, {
-            method: 'POST',
-            headers: buildHeaders(creds),
-            body: JSON.stringify({ userId, role }),
-        });
-        if (!res.ok) {
-            const body = await res.text().catch(() => '');
-            runtimeLog.warn('AgreementClient', `⚠️ Link user failed: ${res.status} ${res.statusText} ${body?.slice(0, 200)}`);
-            return null;
-        }
-        return await res.json().catch(() => null);
-    }
-    catch (e) {
-        runtimeLog.warn('AgreementClient', `⚠️ Link user failed: ${e.message}`);
-        return null;
-    }
-}
-export async function getUsersForAgreement(agreementId, creds) {
-    if (!agreementId)
-        return [];
-    assertCreds(creds, 'get users for agreement');
-    try {
-        const res = await fetch(`${getAgreementBaseUrl()}/${agreementId}/users`, {
-            method: 'GET',
-            headers: buildHeaders(creds),
-        });
-        if (!res.ok) {
-            const body = await res.text().catch(() => '');
-            runtimeLog.warn('AgreementClient', `⚠️ Get users failed: ${res.status} ${res.statusText} ${body?.slice(0, 200)}`);
-            return [];
-        }
-        const data = await res.json().catch(() => null);
-        return Array.isArray(data?.['users']) ? data['users'] : [];
-    }
-    catch (e) {
-        runtimeLog.warn('AgreementClient', `⚠️ Get users failed: ${e.message}`);
-        return [];
-    }
-}
 export class AgreementClient {
     creds;
     /**
@@ -699,6 +642,4 @@ export class AgreementClient {
     listChats(id) { return getChatsForAgreement(id, this.creds); }
     linkArtifact(id, artifactId, linkType) { return linkArtifactToAgreement(id, artifactId, linkType ?? 'produced', this.creds); }
     listArtifacts(id) { return getArtifactsForAgreement(id, this.creds); }
-    linkUser(id, userId, role) { return linkUserToAgreement(id, userId, role, this.creds); }
-    listUsers(id) { return getUsersForAgreement(id, this.creds); }
 }

package/dist/http/ContextGrantsClient.d.ts

@@ -1,10 +1,16 @@
+import { CONTEXT_GRANT_SCOPE_KINDS } 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
- * rail, not a new grant primitive.
+ * The context rail's scopes. `artifact` is the narrowest — one specific
+ * artifact, shared without sharing any chat or agreement it sits in. `task` is
+ * a branch of a work graph: the named task and everything under it. Both are
+ * still the context rail, not new grant primitives.
+ *
+ * Derived from {@link CONTEXT_GRANT_SCOPE_KINDS} rather than written out again:
+ * a hand-copied subset still typechecks against the union, which is how this
+ * list sat a scope kind behind the rail.
  */
-export type ContextGrantScopeKind = 'chat' | 'agreement' | 'org' | 'artifact';
+export type ContextGrantScopeKind = (typeof CONTEXT_GRANT_SCOPE_KINDS)[number];
 export type ContextTemporal = 'from-now' | 'from-start';
 export interface ContextGrantScope {
     kind: ContextGrantScopeKind;

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,22 +23,6 @@ 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 PublishRequestPayload {
-    /** See PublishOfferPayload.billing. */
-    billing?: 'total' | 'per_task';
-    description: string;
-    chatId?: string;
-    payerId?: string;
-    price?: number;
-    lifecycle?: string;
-    expiresAt?: string;
-    maxExecutions?: number;
-    agreementDescription?: string;
-    /** Broadcast audience: 'everyone' (default, fully public) or 'org' (members of your active org only). */
-    audience?: BroadcastAudience;
-}
-export declare function publishRequest(payload: PublishRequestPayload, creds: Creds): Promise<Agreement>;
 export interface PullRequestsOptions {
     limit?: number;
     since?: string;
@@ -53,7 +37,5 @@ export declare class MarketplaceClient {
     constructor(operatorKey: string, agentId?: string);
     publishOffer(payload: PublishOfferPayload): Promise<Agreement>;
     pullOffers(options?: PullOffersOptions): Promise<Agreement[]>;
-    claimOffer(agreementId: string): Promise<Agreement>;
-    publishRequest(payload: PublishRequestPayload): Promise<Agreement>;
     pullRequests(options?: PullRequestsOptions): Promise<Agreement[]>;
 }

package/dist/http/MarketplaceClient.js

@@ -52,40 +52,6 @@ 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 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, `Request publish failed: ${res.status}`);
-    }
-    const data = await res.json().catch(() => null);
-    if (!data?.['agreement'])
-        throw new Error('Request publish returned no agreement');
-    return shapeAgreement(data['agreement']);
-}
 export async function pullRequests(options, creds) {
     assertCreds(creds, 'request pull');
     const params = new URLSearchParams();
@@ -120,7 +86,5 @@ export class MarketplaceClient {
     }
     publishOffer(payload) { return publishOffer(payload, this.creds); }
     pullOffers(options) { return pullOffers(options, this.creds); }
-    claimOffer(agreementId) { return claimOffer(agreementId, this.creds); }
-    publishRequest(payload) { return publishRequest(payload, this.creds); }
     pullRequests(options) { return pullRequests(options, this.creds); }
 }

package/dist/http/TaskClient.d.ts

@@ -37,10 +37,24 @@ export interface CreateTaskData {
     planReviewTiming?: PlanReviewTiming;
     requireMidWorkPlanAck?: boolean;
     idempotencyKey?: string;
-    /** Explicit delegation target — must be a party to the agreement; validated server-side. */
+    /**
+     * Explicit delegation target — must hold a grant on the agreement, so work
+     * can only be handed to someone that contract already reaches; validated
+     * server-side.
+     */
     assigneeId?: string;
     /** prior-step artifact handles consumed as structured input links. */
     inputArtifactIds?: string[];
+    /**
+     * Tasks this one waits for. The task is created immediately, but its assignee
+     * is not woken and cannot start it until every task named here is terminal.
+     * Declaring an edge needs read reach on the task you name.
+     *
+     * Declared rather than enacted: state the join up front and the platform
+     * wakes the joiner once, instead of a live agent polling for it and holding
+     * the shape in its own control flow where nothing else can see it.
+     */
+    waitsOn?: string[];
 }
 export declare function createTask(taskData: CreateTaskData, creds: Creds): Promise<Task>;
 export declare function getTask(taskId: string, creds: Creds): Promise<Task>;

package/dist/http/TaskClient.js

@@ -1,4 +1,5 @@
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { partyActorIds } from '../types.js';
 import { throwApiError } from '../shared/apiError.js';
 function getTaskBaseUrl() { return `${getBackendUrl()}/tasks`; }
 function buildHeaders(creds) {
@@ -159,13 +160,7 @@ async function getActiveTasksForAgentViaPartyAgreements(agentId, creds) {
     const { listAgreements } = await import('./AgreementClient.js');
     const agreements = await listAgreements({ status: 'active' }, creds);
     const partyIds = agreements
-        .filter((a) => {
-        const p = a.parties ?? {};
-        return (p.provider === agentId ||
-            p.providerAgent === agentId ||
-            p.creator === agentId ||
-            p.payer === agentId);
-    })
+        .filter((a) => partyActorIds(a.parties).includes(agentId))
         .map((a) => a.agreementId)
         .filter(Boolean);
     if (partyIds.length === 0)

package/dist/http/agreementFlows.d.ts

@@ -1,4 +1,4 @@
-import { type ClaimedKind, type ProposeTerms } from './AgreementClient.js';
+import { type ClaimedKind, type ClaimOptions, type ProposeTerms } from './AgreementClient.js';
 import { type Agreement, type Creds, type EngagementKind } from '../types.js';
 /**
  * one propose grammar. Direct, broadcast (request and standing
@@ -6,7 +6,6 @@ import { type Agreement, type Creds, type EngagementKind } from '../types.js';
  * single propose tool instead of dedicated publish/request tools.
  *
  * Routing:
- * - engagementKind 'link'                    → POST /agreements (link proposal / open invite)
  * - proposedTo 'everyone' | 'org', providerId = self  → seller-broadcast standing offer
  * - proposedTo 'everyone' | 'org', no providerId      → buyer-broadcast request
  * - anything else                            → direct proposal
@@ -17,7 +16,7 @@ export interface UnifiedProposeInput extends ProposeTerms {
     chatId?: string;
     engagementKind?: EngagementKind;
 }
-export type ProposeShape = 'direct' | 'request' | 'offer' | 'link';
+export type ProposeShape = 'direct' | 'request' | 'offer';
 export declare function proposeUnified(input: UnifiedProposeInput, creds: Creds): Promise<{
     agreement: Agreement;
     shape: ProposeShape;
@@ -36,7 +35,7 @@ export declare function proposeUnified(input: UnifiedProposeInput, creds: Creds)
  * `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<{
+export declare function claimOpenAgreement(agreementId: string, creds: Creds, opts?: ClaimOptions): Promise<{
     agreement: Agreement;
     kind: ClaimedKind;
 }>;