@ziggs-ai/api-client 0.10.4 → 0.11.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`.
  */
@@ -146,7 +146,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,21 +181,26 @@ 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 {
+    /** Target agent for a direct link. Omit for an open, claimable invite. */
+    targetAgentId?: 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>;
+    /** Which of the caller's own agents stands on their side of the link. */
+    asAgentId?: string;
 }
-export declare function createAgreement(body: CreateAgreementBody, creds: Creds): Promise<{
+/**
+ * Create a trust link — a direct proposal to one agent, or an open 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<{
     ok: boolean;
     agreement: Agreement;
 }>;
@@ -210,12 +215,12 @@ 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.
@@ -262,7 +267,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<{
+    createLink(data: CreateLinkBody): Promise<{
         ok: boolean;
         agreement: Agreement;
     }>;

package/dist/http/AgreementClient.js

@@ -103,7 +103,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`.
  */
@@ -172,7 +172,7 @@ export async function respondToAgreement(agreementId, action, creds, opts = {})
     const proposedTo = agreement.parties?.proposedTo;
     if (isBroadcastTarget(proposedTo) || isBroadcastTarget(agreement.parties?.payer)) {
         // 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.
         //
@@ -232,7 +232,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,23 +406,31 @@ export async function getAgreement(agreementId, creds) {
     const agreement = await getAgreementDocument(agreementId, creds);
     return agreement ? shapeAgreement(agreement) : null;
 }
-export async function createAgreement(body, creds) {
+/**
+ * Create a trust link — a direct proposal to one agent, or an open 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');
+        throw new Error('Invalid response: expected { ok, agreement } from POST /agreements/links');
     }
     const envelope = data;
     return { ...envelope, agreement: shapeAgreement(envelope.agreement) };
@@ -472,8 +480,8 @@ export async function fulfillAgreement(agreementId, creds) {
 /**
  * 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.
@@ -493,7 +501,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 +691,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/MarketplaceClient.d.ts

@@ -24,7 +24,7 @@ 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 {
+export interface PublishRequestPayload {
     /** See PublishOfferPayload.billing. */
     billing?: 'total' | 'per_task';
     description: string;
@@ -38,12 +38,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;
     /**
@@ -54,6 +54,6 @@ export declare class MarketplaceClient {
     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

@@ -70,37 +70,37 @@ export async function claimOffer(agreementId, creds) {
         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'] ?? [];
@@ -121,6 +121,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[];

package/dist/http/TaskClient.js

@@ -345,6 +345,8 @@ export async function listTasks(options = {}, creds) {
         url.searchParams.set('limit', String(options.limit));
     if (options.assignedTo)
         url.searchParams.set('assignedTo', options.assignedTo);
+    if (options.createdBy)
+        url.searchParams.set('createdBy', options.createdBy);
     const res = await fetch(url.toString(), {
         method: 'GET',
         headers: buildHeaders(creds),

package/dist/http/agreementFlows.d.ts

@@ -1,14 +1,14 @@
 import { type ClaimedKind, type ProposeTerms } from './AgreementClient.js';
 import { type Agreement, type Creds, type EngagementKind } from '../types.js';
 /**
- * one propose grammar. Direct, broadcast (quest and standing
+ * one propose grammar. Direct, broadcast (request and standing
  * offer), and link proposals all flow through here; the surfaces expose a
  * 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 quest
+ * - proposedTo 'everyone' | 'org', no providerId      → buyer-broadcast request
  * - anything else                            → direct proposal
  */
 export interface UnifiedProposeInput extends ProposeTerms {
@@ -17,13 +17,13 @@ export interface UnifiedProposeInput extends ProposeTerms {
     chatId?: string;
     engagementKind?: EngagementKind;
 }
-export type ProposeShape = 'direct' | 'quest' | 'offer' | 'link';
+export type ProposeShape = 'direct' | 'request' | 'offer' | 'link';
 export declare function proposeUnified(input: UnifiedProposeInput, creds: Creds): Promise<{
     agreement: Agreement;
     shape: ProposeShape;
 }>;
 /**
- * one claim verb for any open broadcast: link invite, quest,
+ * one claim verb for any open broadcast: link invite, request,
  * hand-off, or standing offer.
  *
  * One request. This used to read the agreement first to decide which endpoint to

package/dist/http/agreementFlows.js

@@ -1,4 +1,4 @@
-import { createAgreement, claimAgreement, proposeBroadcast, proposeDirectTo, } from './AgreementClient.js';
+import { createLink, claimAgreement, proposeBroadcast, proposeDirectTo, } from './AgreementClient.js';
 import { publishOffer } from './MarketplaceClient.js';
 import { isBroadcastTarget, } from '../types.js';
 export async function proposeUnified(input, creds) {
@@ -9,9 +9,8 @@ export async function proposeUnified(input, creds) {
         // A link is an agreement, proposed to one agent (providerId) or opened as
         // an invite (proposedTo 'everyone'); no chat, no money.
         const target = isBroadcastTarget(proposedTo) ? undefined : proposedTo;
-        const { agreement } = await createAgreement({
-            engagementKind: 'link',
-            ...(target ? { providerId: target } : {}),
+        const { agreement } = await createLink({
+            ...(target ? { targetAgentId: target } : {}),
             ...(terms.description ? { description: terms.description } : {}),
         }, creds);
         return { agreement, shape: 'link' };
@@ -33,16 +32,16 @@ export async function proposeUnified(input, creds) {
             return { agreement, shape: 'offer' };
         }
         if (providerId) {
-            throw new Error('On a broadcast, providerId must be your own agent id (a standing offer: you work, the claimer pays) or omitted (a quest: the claimer works, you pay). A third-party providerId is not broadcastable.');
+            throw new Error('On a broadcast, providerId must be your own agent id (a standing offer: you work, the claimer pays) or omitted (a request: the claimer works, you pay). A third-party providerId is not broadcastable.');
         }
-        // Buyer-broadcast: the claimer works, your side pays — an open quest.
+        // Buyer-broadcast: the claimer works, your side pays — an open request.
         const agreement = await proposeBroadcast({
             ...terms,
             chatId: chatId ?? '',
             engagementKind: engagementKind ?? 'service',
             audience,
         }, creds);
-        return { agreement, shape: 'quest' };
+        return { agreement, shape: 'request' };
     }
     if (!chatId)
         throw new Error('chatId is required on a direct proposal');
@@ -56,7 +55,7 @@ export async function proposeUnified(input, creds) {
     return { agreement, shape: 'direct' };
 }
 /**
- * one claim verb for any open broadcast: link invite, quest,
+ * one claim verb for any open broadcast: link invite, request,
  * hand-off, or standing offer.
  *
  * One request. This used to read the agreement first to decide which endpoint to
@@ -74,6 +73,6 @@ export async function claimOpenAgreement(agreementId, creds) {
         throw new Error('agreementId is required');
     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' };
+    // 'request' is the shape the route has always handled.
+    return { agreement, kind: kind ?? 'request' };
 }

package/dist/http/grants.d.ts

@@ -11,6 +11,23 @@
  * watermark are presented as `temporal` / `watermark_at` caveats.
  */
 export type GrantHealth = 'active' | 'expired' | 'revoked';
+/**
+ * Who holds a grant. Declared at issuance and carried on the row — nothing
+ * about an id says what it names. An `org` holder is how one grant covers every
+ * member of that organization.
+ */
+export type GrantHolderKind = 'user' | 'org' | 'agent';
+/**
+ * What a grant lets its holder do. `write` implies `read`, `admit` implies
+ * both: `read` sees the scope, `write` takes part in it, `admit` brings others
+ * in as well.
+ */
+export type GrantAccessKind = 'read' | 'write' | 'admit';
+/**
+ * The kind of principal-authored consent object a grant rests on. Every grant
+ * is minted by one of these, or delegated from a parent grant that was.
+ */
+export type GrantBasisKind = 'creation' | 'publication' | 'membership' | 'acceptance' | 'agreement';
 /**
  * The context rail's scope kinds, as VALUES — the type below is derived from
  * them, so widening the rail is one edit rather than a type change plus however
@@ -51,6 +68,17 @@ export interface GrantView {
     /** ISO-8601. */
     createdAt: string;
     health: GrantHealth;
+    /**
+     * What the holder is, what the grant lets them do, and which consent object
+     * authorized it. Present on rails that record them (context grants do);
+     * absent means the rail does not say, not that there is nothing.
+     */
+    holderKind?: GrantHolderKind;
+    access?: GrantAccessKind;
+    basis?: {
+        kind: GrantBasisKind;
+        id: string | null;
+    };
 }
 /** Value of the first caveat of `type` on a grant, or undefined. */
 export declare function grantCaveat(grant: GrantView, type: string): unknown | undefined;

package/dist/http/index.d.ts

@@ -8,7 +8,7 @@ export type { ListMessagesOptions, ListMessagesResult } from './MessagesClient.j
 export { ArtifactsClient, artifactScopeForSession, AGREEMENT_LANE_PREFIX, ARTIFACT_INLINE_TEXT_MAX_CHARS, ARTIFACT_INLINE_TEXT_OVER_LIMIT_HINT, } from './ArtifactsClient.js';
 export type { ArtifactVisibility, ListArtifactsOptions, ListArtifactsQuery, ListArtifactsResult, WriteArtifactInput, } from './ArtifactsClient.js';
 export { ContextReadClient, CONTEXT_READ_TYPES, CONTEXT_READ_VIA, VIA_KINDS, parseVia, viaHint, } from './ContextReadClient.js';
-export type { ContextReadType, ContextReadQuery, ContextReadEnvelope, ContextSnapshotResult, ViaKind, } from './ContextReadClient.js';
+export type { ContextReadType, ContextReadQuery, ContextReadEnvelope, ContextSnapshotResult, ContextSnapshotParticipant, ViaKind, } from './ContextReadClient.js';
 export { ContextDiscoveryClient } from './ContextDiscoveryClient.js';
 export type { DiscoverableItem } from './ContextDiscoveryClient.js';
 export { GrantsClient } from './GrantsClient.js';
@@ -16,7 +16,7 @@ export type { ListGrantsQuery, ListGrantsResult, UnreadableRail } from './Grants
 export { ContextGrantsClient } from './ContextGrantsClient.js';
 export type { ContextGrantRecord, ContextGrantScope, ContextGrantScopeKind, ContextTemporal, IssueContextGrantInput, DelegateContextGrantInput, DelegateContextGrantResult, ReachEntry, GrantReachResult, } from './ContextGrantsClient.js';
 export { grantCaveat, CONTEXT_GRANT_SCOPE_KINDS, GRANT_SCOPE_KINDS, } from './grants.js';
-export type { GrantView, GrantScopeKind, GrantScopeView, GrantCaveatView, GrantHealth, } from './grants.js';
+export type { GrantView, GrantScopeKind, GrantScopeView, GrantCaveatView, GrantHealth, GrantHolderKind, GrantAccessKind, GrantBasisKind, } from './grants.js';
 export { PaymentsClient } from './PaymentsClient.js';
 export type { PaymentsError, WalletBalance, WalletRef, PaymentTransactionView, TransferResult, HoldResult, ReleaseResult, PaymentGrantView, PaymentGrantEnvelope, RevokeGrantResult, PaymentApproval, WaitForApprovalResult, } from './PaymentsClient.js';
 export { ConnectionsClient, assertNoLeakedConnectionSecret, } from './ConnectionsClient.js';

package/dist/index.d.ts

@@ -11,5 +11,5 @@ export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';
 export { RateLimitedError, isRateLimited, parseRetryAfterMs, pollSurfaceError, } from './shared/rateLimit.js';
 export { parseErrorMessage, parseErrorCode, throwApiError, } from './shared/apiError.js';
 export { ApiError } from './types.js';
-export type { Creds, Task, TaskState, PlanStep, PlanStepStatus, Agreement, EngagementKind, BroadcastAudience, EntryType, ContentType, MessageMetadata, MessageHandler, InboxDeliveryKind, InboxDeliveryRef, InboxChatNews, InboxProposalRef, InboxTaskRef, InboxQuestRef, InboxConnectionRequestRef, InboxHumanAttention, InboxEnvelope, InboxAckResult, InboxReadOptions, } from './types.js';
+export type { Creds, Task, TaskState, PlanStep, PlanStepStatus, Agreement, EngagementKind, BroadcastAudience, EntryType, ContentType, MessageMetadata, MessageHandler, InboxDeliveryKind, InboxDeliveryRef, InboxChatNews, InboxProposalRef, InboxTaskRef, InboxRequestRef, InboxConnectionRequestRef, InboxHumanAttention, InboxEnvelope, InboxAckResult, InboxReadOptions, } from './types.js';
 export type { ProposeTerms, ProposeDirectInput, ProposeBroadcastInput, ProposeAgreementData, } from './http/AgreementClient.js';