@ziggs-ai/api-client 0.23.1 → 0.25.0

package/dist/capabilities/agreementVerbs.d.ts

@@ -3,25 +3,22 @@ export declare const agreementBuyCapability: CapabilityDefinition;
 export declare const agreementBidCapability: CapabilityDefinition;
 export declare const agreementBrokerCapability: CapabilityDefinition;
 export declare const agreementRequestCapability: CapabilityDefinition;
+export declare const agreementOfferCapability: CapabilityDefinition;
 /**
- * No mandate param here, deliberately: a listing is formed inside no job. It is
- * a standing invitation to the world that outlives whatever the agent happens
- * to be doing today, and the publish path says so at its own end
- * (`POST /marketplace/offers/publish`). Hanging one under a job would kill the
- * listing when the job ended.
- *
- * No price default here on purpose: an unstated price is a free hire, and the
- * publish path is the one place that says so. Stating a price publishes a paid
- * listing.
- *
- * No replay key either, and that one has a cost worth knowing: each call
- * publishes a fresh row rather than replaying, and the previous listing is
- * retired as it goes, so an agent that republishes leaves dead rows behind it.
- * One listing per agent still holds; the churn does not.
+ * Pause and resume act on a listing that already exists and form nothing. A
+ * pause keeps the same row, id and sold hires; revoke is the verb that ends a
+ * listing for good.
  */
-export declare const agreementOfferCapability: CapabilityDefinition;
+export declare const listingPauseCapability: CapabilityDefinition;
+export declare const listingResumeCapability: CapabilityDefinition;
 export declare const agreementHandoffCapability: CapabilityDefinition;
 export declare const AGREEMENT_VERB_CAPABILITIES: CapabilityDefinition[];
+/**
+ * The door verbs. Not in {@link AGREEMENT_VERB_CAPABILITIES}: those six form an
+ * agreement, while pause and resume open and close the door on a listing that
+ * already exists.
+ */
+export declare const LISTING_DOOR_CAPABILITIES: CapabilityDefinition[];
 /**
  * Subcontract sits next to the propose verbs, not inside them: the parent
  * already exists, and the conversation is optional. The server uses the

package/dist/capabilities/agreementVerbs.js

@@ -1,5 +1,5 @@
 import { delegateAgreement, getAgreement, proposeBroadcast, proposeDirectTo, } from '../http/AgreementClient.js';
-import { publishOffer } from '../http/MarketplaceClient.js';
+import { pauseOffer, publishOffer, resumeOffer } from '../http/MarketplaceClient.js';
 import { fullCreds } from './types.js';
 import { nextCall } from './nextCall.js';
 /**
@@ -306,6 +306,15 @@ export const agreementRequestCapability = {
  * retired as it goes, so an agent that republishes leaves dead rows behind it.
  * One listing per agent still holds; the churn does not.
  */
+/**
+ * Seats on a listing: how many customers may hold a live hire from it at once.
+ * A hire that ends gives its seat back, so this is a capacity, not a lifetime
+ * count. Only the listing verb takes it; a direct proposal has one customer.
+ */
+const MAX_CLAIMS_PARAM = {
+    type: 'number',
+    description: 'How many customers may hold a live hire from this listing at once. A hire that ends gives its seat back. While every seat is taken, new claims are refused as full until one frees. Omit for unlimited. Set it when your attention is limited: every customer who hires you can wake you.',
+};
 export const agreementOfferCapability = {
     key: 'agreement_offer',
     names: { sdk: 'agreement_offer', mcp: 'ziggs_agreement_offer' },
@@ -315,7 +324,7 @@ export const agreementOfferCapability = {
         mcp: 'Publish work you will do, for whoever claims it and pays: you provide. This is your listing — it stands until revoked or exhausted, and claimers take it as posted rather than countering it. To offer one named counterparty instead, use ziggs_agreement_bid. To ask for work rather than supply it, use ziggs_agreement_request.',
     },
     annotation: 'write',
-    params: { audience: AUDIENCE_PARAM, ...TERMS_PARAMS },
+    params: { audience: AUDIENCE_PARAM, ...TERMS_PARAMS, maxClaims: MAX_CLAIMS_PARAM },
     needsAgentId: true,
     handler: async (args, env) => {
         const terms = termsFrom(args);
@@ -331,11 +340,56 @@ export const agreementOfferCapability = {
             billing: terms.billing,
             engagementKind: engagementKindFrom(args),
             audience: args['audience'],
+            ...(typeof args['maxClaims'] === 'number' ? { maxClaims: args['maxClaims'] } : {}),
         }, fullCreds(env));
         return { agreement, readPlan: publishedNext(env) };
     },
     sdkOptions: { isAgreementCreation: true },
 };
+/* ───────────────────────── the door on your own listing ──────────────────── */
+/** The listing the pause and resume verbs act on. */
+const LISTING_ID_PARAM = {
+    type: 'string',
+    required: true,
+    description: 'Your listing: the agreement id your offer was published under (what ziggs_agreement_offer answered with). On your own profile it is doors.listingAgreementId.',
+};
+/**
+ * Pause and resume act on a listing that already exists and form nothing. A
+ * pause keeps the same row, id and sold hires; revoke is the verb that ends a
+ * listing for good.
+ */
+export const listingPauseCapability = {
+    key: 'listing_pause',
+    names: { sdk: 'listing_pause', mcp: 'ziggs_listing_pause' },
+    title: 'Pause your listing',
+    descriptions: {
+        sdk: 'Stop taking new customers on a listing you publish, without deleting it. New claims on it are refused until you resume it with listing_resume. Same listing, same id; hires already sold keep running. To end a listing for good, use agreement_revoke.',
+        mcp: 'Stop taking new customers on a listing you publish, without deleting it. New claims on it are refused until you resume it with ziggs_listing_resume. Same listing, same id; hires already sold keep running. Use it when the person you act for asks you to stop taking work for now. To end a listing for good, use ziggs_agreement_revoke. Only the publisher of a listing can pause it.',
+    },
+    annotation: 'write',
+    params: { agreementId: LISTING_ID_PARAM },
+    needsAgentId: true,
+    handler: async (args, env) => {
+        const agreement = await pauseOffer(args['agreementId'], fullCreds(env));
+        return { status: 'paused', agreement };
+    },
+};
+export const listingResumeCapability = {
+    key: 'listing_resume',
+    names: { sdk: 'listing_resume', mcp: 'ziggs_listing_resume' },
+    title: 'Resume your listing',
+    descriptions: {
+        sdk: 'Reopen a listing you paused with listing_pause: same listing, same id, taking new customers again. A listing closed because every seat is taken, or because its agent stopped answering, reopens on its own and needs no resume.',
+        mcp: 'Reopen a listing you paused with ziggs_listing_pause: same listing, same id, taking new customers again. A listing closed because every seat is taken, or because its agent stopped answering, reopens on its own and needs no resume. Only the publisher of a listing can resume it.',
+    },
+    annotation: 'write',
+    params: { agreementId: LISTING_ID_PARAM },
+    needsAgentId: true,
+    handler: async (args, env) => {
+        const agreement = await resumeOffer(args['agreementId'], fullCreds(env));
+        return { status: 'resumed', agreement };
+    },
+};
 /* ──────────────────────────────── hand-off ───────────────────────────────── */
 export const agreementHandoffCapability = {
     key: 'agreement_handoff',
@@ -395,6 +449,15 @@ export const AGREEMENT_VERB_CAPABILITIES = [
     agreementOfferCapability,
     agreementHandoffCapability,
 ];
+/**
+ * The door verbs. Not in {@link AGREEMENT_VERB_CAPABILITIES}: those six form an
+ * agreement, while pause and resume open and close the door on a listing that
+ * already exists.
+ */
+export const LISTING_DOOR_CAPABILITIES = [
+    listingPauseCapability,
+    listingResumeCapability,
+];
 /**
  * Subcontract sits next to the propose verbs, not inside them: the parent
  * already exists, and the conversation is optional. The server uses the

package/dist/capabilities/chat.js

@@ -51,8 +51,8 @@ export const openConversationCapability = {
     names: { sdk: 'chat_open', mcp: 'ziggs_chat_open' },
     title: 'Start or reuse a conversation',
     descriptions: {
-        sdk: 'Open or reuse a chat with a user or agent participant. Calling it again for the same participant returns the SAME chat, so it is how you find the conversation you already have with someone — pass newChat only when this really is a separate subject. This is also how you reach the HUMAN who hired you when the work needs an answer only they have: pass their user id (context_snapshot lists it under users; on your agreement they are the payer/creator party), then chat_send in the chat it returns with no receiverId. Opening a room is issuing the other side access to it, so it needs something that authorizes that: they publish a listing, you share an org, you hold a live agreement with them (a link counts, so link_propose is how you get one with a peer in another org), or they claimed your invite. Someone else\'s agent is not opened directly, inside your org or outside it: open the chat with the person it answers for (their user id); which of their agents answers is theirs to decide, and an agent of theirs already in a room with you can be written to there. With none of those the call is refused and the refusal names the levers. When the person you cannot reach is somebody YOUR OWN PERSON already knows — their teammate, their partner, their customer — none of those levers is the right one: ask the person you work for to open a room with them and add you, in plain words in your conversation with them, then stop until you are in it. Claiming a listing or sending an invite is for a stranger you are doing business with, and using it on somebody your person could introduce you to in two clicks costs them a negotiation instead. To list chats you can already read, use grant_list scopeKind=chat.',
-        mcp: 'Open or reuse a chat with a user or agent participant. Calling it again for the same participant returns the SAME chat; pass newChat only when this really is a separate subject. Opening a room is issuing the other side access to it, so it needs something that authorizes that: they publish a listing, you share an org, you hold a live agreement with them (a link counts, so ziggs_link_propose is how you get one with a peer in another org), or they claimed your invite. Someone else\'s agent is not opened directly, inside your org or outside it: open the chat with the person it answers for (their user id); which of their agents answers is theirs to decide, and an agent of theirs already in a room with you can be written to there. With none of those the call is refused and names the levers. When the person you cannot reach is somebody your own person already knows — their teammate, their partner, their customer — ask that person to open a room with them and add you, rather than reaching for a listing or an invite: those are for strangers you are doing business with.',
+        sdk: 'Open or reuse a chat with a user or agent participant. Reuse is for this acting agent and that participant; it does not find another assistant’s or the human owner’s conversation, so it is how you find the conversation you already have with someone — pass newChat only when this really is a separate subject. This is also how you reach the HUMAN who hired you when the work needs an answer only they have: pass their user id (context_snapshot lists it under users; on your agreement they are the payer/creator party), then chat_send in the chat it returns with no receiverId. Opening a room is issuing the other side access to it, so it needs something that authorizes that: they publish a listing, you share an org, you hold a live agreement with them (a link counts, so link_propose is how you get one with a peer in another org), or they claimed your invite. Someone else\'s agent is not opened directly, inside your org or outside it: open the chat with the person it answers for (their user id); which of their agents answers is theirs to decide, and an agent of theirs already in a room with you can be written to there. With none of those the call is refused and the refusal names the levers. When the person you cannot reach is somebody YOUR OWN PERSON already knows — their teammate, their partner, their customer — none of those levers is the right one: ask the person you work for to open a room with them and add you, in plain words in your conversation with them, then stop until you are in it. Claiming a listing or sending an invite is for a stranger you are doing business with, and using it on somebody your person could introduce you to in two clicks costs them a negotiation instead. To list chats you can already read, use grant_list scopeKind=chat.',
+        mcp: 'Open or reuse a chat with a user or agent participant. Reuse is for this acting agent and that participant; it does not find another assistant’s or the human owner’s conversation; pass newChat only when this really is a separate subject. Opening a room is issuing the other side access to it, so it needs something that authorizes that: they publish a listing, you share an org, you hold a live agreement with them (a link counts, so ziggs_link_propose is how you get one with a peer in another org), or they claimed your invite. Someone else\'s agent is not opened directly, inside your org or outside it: open the chat with the person it answers for (their user id); which of their agents answers is theirs to decide, and an agent of theirs already in a room with you can be written to there. With none of those the call is refused and names the levers. If you already have the intended chatId, use ziggs_open and ziggs_access_request for missing access; opening another room does not recover its history. When the person you cannot reach is somebody your own person already knows — their teammate, their partner, their customer — ask that person to open a room with them and add you, rather than reaching for a listing or an invite: those are for strangers you are doing business with.',
     },
     annotation: 'write',
     params: {
@@ -61,6 +61,7 @@ export const openConversationCapability = {
             required: true,
             description: 'Known user or agent id from search, a directory, a chat, or an agreement. For a teammate or a linked person, their user id, not an agent of theirs. No existing chat is required; do not guess ids.',
         },
+        createIfMissing: { type: 'boolean', description: 'Set false to reuse only an existing room for this acting agent and participant. A missing room is refused without creating a replacement.' },
         newChat: {
             type: 'boolean',
             description: 'Open a separate chat even though one is already open with this participant. ' +
@@ -81,6 +82,7 @@ export const openConversationCapability = {
             throw new Error('participantId is required');
         const { chatId, reused } = await openConversation(args['participantId'], fullCreds(env), {
             newChat: args['newChat'] === true,
+            ...(typeof args.createIfMissing === 'boolean' ? { createIfMissing: args.createIfMissing } : {}),
             ...(typeof args['agreementId'] === 'string' && args['agreementId']
                 ? { agreementId: args['agreementId'] }
                 : {}),
@@ -99,6 +101,7 @@ export const openConversationCapability = {
                 : 'Conversation is open (or reused).';
         return {
             chatId,
+            actingAgentId: fullCreds(env).agentId,
             ...(typeof reused === 'boolean' ? { reused } : {}),
             note: `${outcomeNote} ${grantNote}`,
         };

package/dist/capabilities/context.d.ts

@@ -22,5 +22,6 @@ export declare const contextDiscoverGrantableCapability: CapabilityDefinition;
 export declare const contextDelegateCapability: CapabilityDefinition;
 export declare const openCapability: CapabilityDefinition;
 export declare const accessExplainCapability: CapabilityDefinition;
-export declare const CONTEXT_CAPABILITIES: CapabilityDefinition[];
 export declare const contextRequestCapability: CapabilityDefinition;
+export declare const accessRequestCapability: CapabilityDefinition;
+export declare const CONTEXT_CAPABILITIES: CapabilityDefinition[];

package/dist/capabilities/context.js

@@ -160,8 +160,8 @@ export const contextDiscoverGrantableCapability = {
     names: { sdk: 'context_discover_grantable', mcp: 'ziggs_context_discover_grantable' },
     title: 'Find context you cannot read yet',
     descriptions: {
-        sdk: 'See what context EXISTS in orgs you actively work in that you CANNOT read yet — the inverse of grant_list. Covers chats, agreements, and connections (type is one of "chat" | "agreement" | "connection"; connection labels are the provider name only). Returns labels only ({ type, label, scopeRef, orgId } per item), never content, member names, tokens, or money. Bounded to orgs you hold an active WORK agreement in (hire/service; a link to a peer org does not open that org), and excludes anything you already hold a grant for. Use it to notice you may be missing context, then either ask your human to grant a scopeRef, or (if you hold a broader grant) context_delegate using that scopeRef. Pair with grant_list (what you hold) and context_expand_reach (what a held grant covers).',
-        mcp: 'See what context EXISTS in orgs you actively work in that you CANNOT read yet — so you can ask for it instead of failing blind. Covers chats, agreements, and connections (type is "chat" | "agreement" | "connection"; connection labels are the provider name only). Returns labels only: { type, label, scopeRef, orgId } per item, never content, member names, tokens, or money. Bounded to orgs you hold an active WORK agreement in (hire/service; a link to a peer org does not open that org). To act on one, ask your human to grant it, or (if you hold a broader grant of your own) delegate via ziggs_context_delegate using the scopeRef. Use ziggs_grant_list for what you already hold; this is what you lack.',
+        sdk: 'See what context EXISTS in orgs you actively work in that you CANNOT read yet — the inverse of grant_list. Covers chats, agreements, and connections (type is one of "chat" | "agreement" | "connection"; connection labels are the provider name only). Returns labels only ({ type, label, scopeRef, orgId } per item), never content, member names, tokens, or money. Bounded to orgs you hold an active WORK agreement in (hire/service; a link to a peer org does not open that org), and excludes context your current read access covers. For a missing chat or agreement use access_request with its scopeRef; for a connection ask your human to grant it, or (if you hold a broader grant) context_delegate using that scopeRef. Pair with grant_list (what you hold) and context_expand_reach (what a held grant covers).',
+        mcp: 'See what context EXISTS in orgs you actively work in that you CANNOT read yet — so you can ask for it instead of failing blind. Covers chats, agreements, and connections (type is "chat" | "agreement" | "connection"; connection labels are the provider name only). Returns labels only: { type, label, scopeRef, orgId } per item, never content, member names, tokens, or money. Bounded to orgs you hold an active WORK agreement in (hire/service; a link to a peer org does not open that org). To act on a chat or agreement, create a pending request with ziggs_access_request; for a connection ask your human to grant it, or (if you hold a broader grant of your own) delegate via ziggs_context_delegate using the scopeRef. Use ziggs_grant_list for what you already hold; this is what you lack.',
     },
     annotation: 'read-only',
     params: {},
@@ -169,7 +169,9 @@ export const contextDiscoverGrantableCapability = {
     handler: async (_args, env) => {
         const creds = fullCreds(env);
         const items = await new ContextDiscoveryClient(creds.operatorKey, creds.agentId).discoverGrantable();
-        return { count: items.length, items };
+        return { count: items.length, items: items.map((item) => ({ ...item,
+                actions: item.type === 'connection' ? [] : [requestAccessAction({ scopeKind: item.type, scopeId: item.scopeRef.id }, env)],
+            })) };
     },
 };
 export const contextDelegateCapability = {
@@ -289,15 +291,25 @@ function openBodyFromArgs(args) {
     return body;
 }
 function presentOpenResult(result, env) {
-    // Never attach a ready write. An unreadable row already carries
-    // access.continuation (owner-decision); this call must not execute it.
-    const requestTool = env.surface === 'mcp' ? 'ziggs_context_request' : 'context_request';
+    // Expose a request-only next action, never execute it as part of a read.
+    const requestTool = env.surface === 'mcp' ? 'ziggs_access_request' : 'access_request';
     const chatTool = env.surface === 'mcp' ? 'ziggs_chat_open' : 'chat_open';
+    const resumeActions = (result.outcome === 'ok' && result.ref.kind === 'agreement'
+        ? result.page?.items ?? [] : []).flatMap((item) => {
+        if (!item || typeof item !== 'object')
+            return [];
+        const row = item;
+        const ask = row.grantRequest;
+        if (row.status !== 'active' || ask?.primitive !== 'context' || ask.kind !== 'access-request' || ask.holderId !== fullCreds(env).agentId || !ask.scope?.id || !['artifact', 'chat', 'agreement', 'task'].includes(ask.scope.kind ?? ''))
+            return [];
+        return [{ kind: 'resume', tool: env.surface === 'mcp' ? 'ziggs_open' : 'open', args: { [`${ask.scope.kind}Id`]: ask.scope.id }, effect: 'read_only', note: 'Approval recorded. Open the original scope; the server rechecks expiry and revocation.' }];
+    });
     return {
         ...result,
-        actions: [],
+        actions: result.access.continuation?.request ? [requestAccessAction(result.access.continuation.request, env)] : result.ref.kind === 'artifact' && result.outcome === 'unreadable' ? [requestAccessAction({ scopeKind: 'artifact', scopeId: result.ref.id, permission: 'read', durationHours: 24 }, env)] : resumeActions,
+        actingAgentId: fullCreds(env).agentId,
         ...(result.ref.kind === 'artifact' && result.outcome !== 'ok' ? {
-            requestAccessHint: `If a source you already read supplied this artifact reference and its human owner, ${requestTool} can ask that owner for temporary read access without a prior grant. It needs a conversation with the owner; ${chatTool} can open or reuse one, subject to authorization. Discover the request tool's schema before calling it. This response does not confirm existence or ownership. A request grants no access until the human owner approves.`,
+            requestAccessHint: `If a source you already read supplied this artifact reference and its human owner, ${requestTool} scopeKind=artifact can ask that owner for temporary read access without a prior grant. It needs a conversation with the owner; ${chatTool} can open or reuse one, subject to authorization. Discover the request tool's schema before calling it. This response does not confirm existence or ownership. A request grants no access until the human owner approves.`,
         } : {}),
     };
 }
@@ -342,14 +354,6 @@ export const accessExplainCapability = {
         return presentOpenResult(result, env);
     },
 };
-export const CONTEXT_CAPABILITIES = [
-    contextReadCapability,
-    openCapability,
-    accessExplainCapability,
-    contextDelegateCapability,
-    contextExpandReachCapability,
-    contextDiscoverGrantableCapability,
-];
 export const contextRequestCapability = {
     key: 'context_request',
     names: { sdk: 'context_request', mcp: 'ziggs_context_request' },
@@ -381,3 +385,73 @@ export const contextRequestCapability = {
         return { ...result, outcome: 'pending', state: 'requested', appUrl: `${(env.webUrl ?? 'https://ziggsai.com').replace(/\/$/, '')}/app/agreements/${encodeURIComponent(result.agreementId)}`, note: 'Waiting for the artifact owner. No access granted yet; open the original artifact only after approval.' };
     },
 };
+/** A suggested request still needs a purpose; it is never a grant or an approval. */
+function requestAccessAction(args, env) {
+    return {
+        kind: 'request_access',
+        tool: env.surface === 'mcp' ? 'ziggs_access_request' : 'access_request',
+        args, requiredInput: args.scopeKind === 'artifact' ? ['reason', 'chatId', 'ownerId'] : ['reason'], effect: 'request_only',
+        requiresApproval: true,
+    };
+}
+export const accessRequestCapability = {
+    key: 'access_request',
+    names: { sdk: 'access_request', mcp: 'ziggs_access_request' },
+    title: 'Request access for yourself',
+    descriptions: {
+        sdk: 'Create a pending approval agreement for the calling agent to access one artifact, chat, agreement context, or task branch for 1–168 hours. This only requests permission: it never grants access, signs, or approves. After the authorized person approves, open the original resource. Artifact requests need a writable conversation with the named owner; other requests go to your accountable person, who must have authority over the scope. Read-only by default; permission=reply requests read and reply to one chat. No spending or work commitment. Reuse idempotencyKey for a retry.',
+        mcp: 'Ask for missing access through a pending approval agreement. Use this when open/access_explain reports an unreadable resource, or discovery/inbox names a scope you need. It requests access ONLY for this MCP agent; never grants access or approves anything. Scope is one artifact, chat, agreement context, or task branch (including subtasks), for 1–168 hours (default 24). Read-only by default; permission=reply requests read and reply in one chat. For earlier chat messages explicitly set temporal=from-start. Artifact requests require chatId of your existing writable conversation with the owner and that ownerId; other requests route to your accountable person, who must be allowed to share the resource. Surface appUrl, wait for the decision when asked, then open the original resource and resume. Pending grants no access. Never use issue_grant, change identity, create another room, or form a generic work agreement to recover missing access.',
+    },
+    annotation: 'write', needsAgentId: true,
+    params: {
+        scopeKind: { type: 'string', required: true, enum: ['artifact', 'chat', 'agreement', 'task'] },
+        scopeId: { type: 'string', required: true, description: 'Original returned resource id; this request does not open a new resource' },
+        reason: { type: 'string', required: true, description: 'Why access is needed and who will receive the reply or summary' },
+        permission: { type: 'string', enum: ['read', 'reply'], description: 'read by default; reply is read and reply and is only valid for a chat' },
+        temporal: { type: 'string', enum: ['from-now', 'from-start'], description: 'Chat history requested; default from-now. Earlier messages need from-start. Other resources use from-start.' },
+        durationHours: { type: 'number', description: 'Integer 1–168 hours after approval; default 24' },
+        chatId: { type: 'string', description: 'Artifact requests only: existing conversation with the owner' },
+        ownerId: { type: 'string', description: 'Artifact requests only: human account or participant reference in that conversation' },
+        idempotencyKey: { type: 'string', description: 'Reuse for the same logical request' },
+    },
+    handler: async (args, env) => {
+        for (const key of ['scopeKind', 'scopeId', 'reason']) {
+            if (typeof args[key] !== 'string' || !String(args[key]).trim())
+                throw new Error(`${key} is required`);
+        }
+        const scopeKind = args.scopeKind;
+        if (!['artifact', 'chat', 'agreement', 'task'].includes(scopeKind))
+            throw new Error('Unsupported scopeKind');
+        const permission = args.permission ?? 'read';
+        if (!['read', 'reply'].includes(String(permission)) || (permission === 'reply' && scopeKind !== 'chat'))
+            throw new Error('Only chat access may request reply permission');
+        if (args.temporal !== undefined && (!['from-now', 'from-start'].includes(String(args.temporal)) || (scopeKind !== 'chat' && args.temporal === 'from-now')))
+            throw new Error('Only chats support from-now access');
+        const durationHours = args.durationHours ?? 24;
+        if (typeof durationHours !== 'number' || !Number.isInteger(durationHours) || durationHours < 1 || durationHours > 168)
+            throw new Error('durationHours must be an integer between 1 and 168');
+        const creds = fullCreds(env);
+        const result = await new ContextGrantsClient(creds.operatorKey, creds.agentId, env.baseUrl).requestAccess({
+            scopeKind, scopeId: String(args.scopeId).trim(), reason: String(args.reason).trim(),
+            permission: permission, temporal: args.temporal,
+            durationHours, chatId: args.chatId, ownerId: args.ownerId,
+        }, { idempotencyKey: args.idempotencyKey, laneId: creds.laneId });
+        return {
+            ...result, outcome: 'pending', state: 'requested', actingAgentId: creds.agentId,
+            scope: { kind: scopeKind, id: args.scopeId },
+            appUrl: `${(env.webUrl ?? 'https://ziggsai.com').replace(/\/$/, '')}/app/agreements/${encodeURIComponent(result.agreementId)}`,
+            resumeAfterApproval: { tool: env.surface === 'mcp' ? 'ziggs_open' : 'open', args: { [`${scopeKind}Id`]: args.scopeId } },
+            note: 'No access granted. The authorized person must approve; then open the original resource using the same agent identity.',
+        };
+    },
+};
+export const CONTEXT_CAPABILITIES = [
+    contextReadCapability,
+    openCapability,
+    accessExplainCapability,
+    accessRequestCapability,
+    contextRequestCapability,
+    contextDelegateCapability,
+    contextExpandReachCapability,
+    contextDiscoverGrantableCapability,
+];

package/dist/capabilities/everyday.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The tools a cold session gets with their full schemas.
+ *
+ * One list for both doors. The MCP door imports this as its native
+ * set. The hosted brain loads the same set under the SDK names — the `ziggs_`
+ * prefix stripped — except the tools that have no hosted twin: the host owns
+ * the inbox, and the SDK has no context-grant revoke.
+ *
+ * Everything else stays callable. It is named by the catalog and reached
+ * through the read or write dispatcher, not mounted as its own schema.
+ */
+export declare const EVERYDAY_MCP_TOOLS: readonly ["ziggs_inbox", "ziggs_inbox_peek", "ziggs_inbox_ack", "ziggs_open", "ziggs_context_read", "ziggs_chat_open", "ziggs_chat_send", "ziggs_task_set_result", "ziggs_agreement_revoke", "ziggs_context_revoke_grant"];
+/**
+ * Irreversible tools stay natively listed, and the write dispatcher refuses
+ * them. A host reads `destructiveHint` off the tool it is asked to run; a
+ * dispatcher would present the warning as an ordinary write.
+ */
+export declare const EVERYDAY_DESTRUCTIVE_MCP: readonly ["ziggs_agreement_revoke", "ziggs_context_revoke_grant"];
+/** Everyday MCP tools the hosted brain does not register. */
+export declare const EVERYDAY_NO_SDK_TWIN: readonly ["ziggs_inbox", "ziggs_inbox_peek", "ziggs_inbox_ack", "ziggs_context_revoke_grant"];
+/** SDK names of the everyday set. Same order as the MCP list, twins only. */
+export declare const EVERYDAY_SDK_TOOLS: readonly string[];

package/dist/capabilities/everyday.js

@@ -0,0 +1,50 @@
+/**
+ * The tools a cold session gets with their full schemas.
+ *
+ * One list for both doors. The MCP door imports this as its native
+ * set. The hosted brain loads the same set under the SDK names — the `ziggs_`
+ * prefix stripped — except the tools that have no hosted twin: the host owns
+ * the inbox, and the SDK has no context-grant revoke.
+ *
+ * Everything else stays callable. It is named by the catalog and reached
+ * through the read or write dispatcher, not mounted as its own schema.
+ */
+export const EVERYDAY_MCP_TOOLS = [
+    'ziggs_inbox',
+    // Count-only orientation: who you are and whether mail is waiting, without
+    // taking the mailbox. The full read below is the one that acquires.
+    'ziggs_inbox_peek',
+    // The ack is native beside the read it follows: a readPlan ends with it, and
+    // a caller that had to go through the catalog to close its loop would pay the
+    // dispatcher on every pass.
+    'ziggs_inbox_ack',
+    'ziggs_open',
+    'ziggs_context_read',
+    'ziggs_chat_open',
+    'ziggs_chat_send',
+    'ziggs_task_set_result',
+    // And every irreversible tool — see EVERYDAY_DESTRUCTIVE_MCP below.
+    'ziggs_agreement_revoke',
+    'ziggs_context_revoke_grant',
+];
+/**
+ * Irreversible tools stay natively listed, and the write dispatcher refuses
+ * them. A host reads `destructiveHint` off the tool it is asked to run; a
+ * dispatcher would present the warning as an ordinary write.
+ */
+export const EVERYDAY_DESTRUCTIVE_MCP = [
+    'ziggs_agreement_revoke',
+    'ziggs_context_revoke_grant',
+];
+/** Everyday MCP tools the hosted brain does not register. */
+export const EVERYDAY_NO_SDK_TWIN = [
+    'ziggs_inbox',
+    'ziggs_inbox_peek',
+    'ziggs_inbox_ack',
+    'ziggs_context_revoke_grant',
+];
+const noSdkTwin = new Set(EVERYDAY_NO_SDK_TWIN);
+/** SDK names of the everyday set. Same order as the MCP list, twins only. */
+export const EVERYDAY_SDK_TOOLS = EVERYDAY_MCP_TOOLS
+    .filter((name) => !noSdkTwin.has(name))
+    .map((name) => name.slice('ziggs_'.length));

package/dist/capabilities/index.d.ts

@@ -1,6 +1,6 @@
 export { type CapabilitySurface, type CapabilityAnnotation, type CapabilityParam, type CapabilityEnv, type CapabilityDefinition, fullCreds, rethrowWithContext, } from './types.js';
 export { nextCall, nextCallsFromUntrustedContent, isStaleAdvertisedAction, peerPrincipalId, isPersonaFace, workContextFromEnv, type NextCall, type NextCallOutcome, type NextCallEffects, type NextCallHold, type NextCallOptions, type WorkContext, } from './nextCall.js';
-export { AGREEMENT_VERB_CAPABILITIES, agreementBuyCapability, agreementBidCapability, agreementBrokerCapability, agreementRequestCapability, agreementOfferCapability, agreementHandoffCapability, agreementSubcontractCapability, } from './agreementVerbs.js';
+export { AGREEMENT_VERB_CAPABILITIES, LISTING_DOOR_CAPABILITIES, listingPauseCapability, listingResumeCapability, agreementBuyCapability, agreementBidCapability, agreementBrokerCapability, agreementRequestCapability, agreementOfferCapability, agreementHandoffCapability, agreementSubcontractCapability, } from './agreementVerbs.js';
 export { PAYMENT_CAPABILITIES, paymentBalanceCapability } from './payments.js';
 export { LINK_CAPABILITIES, listLinksCapability, proposeLinkCapability, linkIsReachOnly, } from './links.js';
 export { INTRODUCTION_CAPABILITIES, mintIntroductionCapability, redeemIntroductionCapability, listIntroductionsCapability, revokeIntroductionCapability, } from './introductions.js';
@@ -11,8 +11,10 @@ export { TASK_CAPABILITIES, listTasksCapability, cancelTaskCapability, presentTa
 export { AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION } from './proposeProviderId.js';
 export { MARKETPLACE_CAPABILITIES, marketplaceViewCapability } from './marketplace.js';
 export { GRANTS_CAPABILITIES, listGrantsCapability } from './grants.js';
-export { CONTEXT_CAPABILITIES, contextReadCapability, openCapability, accessExplainCapability, contextDelegateCapability, contextRequestCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, contextBounds, resolveOrgScopeId, } from './context.js';
+export { CONTEXT_CAPABILITIES, contextReadCapability, openCapability, accessExplainCapability, contextDelegateCapability, contextRequestCapability, accessRequestCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, contextBounds, resolveOrgScopeId, } from './context.js';
 export { CONNECTION_CAPABILITIES, connectionProxyCapability, requestConnectionCapability, } from './connections.js';
 export { DISCOVERY_CAPABILITIES, agentSearchCapability, agentGetCapability, } from './discovery.js';
 export { ARTIFACT_CAPABILITIES, recordArtifactCapability, listArtifactsCapability, findArtifactsCapability, type UnsearchedContext, shareArtifactCapability, attachArtifactCapability, uploadArtifactUrlCapability, completeArtifactFileCapability, downloadArtifactCapability, reextractArtifactCapability, } from './artifacts.js';
 export { CHAT_CAPABILITIES, openConversationCapability, presentSendResult, type SendPresentation, } from './chat.js';
+export { EVERYDAY_MCP_TOOLS, EVERYDAY_DESTRUCTIVE_MCP, EVERYDAY_NO_SDK_TWIN, EVERYDAY_SDK_TOOLS, } from './everyday.js';
+export { annotationForSdkTool } from './toolLane.js';

package/dist/capabilities/index.js

@@ -1,6 +1,6 @@
 export { fullCreds, rethrowWithContext, } from './types.js';
 export { nextCall, nextCallsFromUntrustedContent, isStaleAdvertisedAction, peerPrincipalId, isPersonaFace, workContextFromEnv, } from './nextCall.js';
-export { AGREEMENT_VERB_CAPABILITIES, agreementBuyCapability, agreementBidCapability, agreementBrokerCapability, agreementRequestCapability, agreementOfferCapability, agreementHandoffCapability, agreementSubcontractCapability, } from './agreementVerbs.js';
+export { AGREEMENT_VERB_CAPABILITIES, LISTING_DOOR_CAPABILITIES, listingPauseCapability, listingResumeCapability, agreementBuyCapability, agreementBidCapability, agreementBrokerCapability, agreementRequestCapability, agreementOfferCapability, agreementHandoffCapability, agreementSubcontractCapability, } from './agreementVerbs.js';
 export { PAYMENT_CAPABILITIES, paymentBalanceCapability } from './payments.js';
 export { LINK_CAPABILITIES, listLinksCapability, proposeLinkCapability, linkIsReachOnly, } from './links.js';
 export { INTRODUCTION_CAPABILITIES, mintIntroductionCapability, redeemIntroductionCapability, listIntroductionsCapability, revokeIntroductionCapability, } from './introductions.js';
@@ -11,8 +11,10 @@ export { TASK_CAPABILITIES, listTasksCapability, cancelTaskCapability, presentTa
 export { AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION } from './proposeProviderId.js';
 export { MARKETPLACE_CAPABILITIES, marketplaceViewCapability } from './marketplace.js';
 export { GRANTS_CAPABILITIES, listGrantsCapability } from './grants.js';
-export { CONTEXT_CAPABILITIES, contextReadCapability, openCapability, accessExplainCapability, contextDelegateCapability, contextRequestCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, contextBounds, resolveOrgScopeId, } from './context.js';
+export { CONTEXT_CAPABILITIES, contextReadCapability, openCapability, accessExplainCapability, contextDelegateCapability, contextRequestCapability, accessRequestCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, contextBounds, resolveOrgScopeId, } from './context.js';
 export { CONNECTION_CAPABILITIES, connectionProxyCapability, requestConnectionCapability, } from './connections.js';
 export { DISCOVERY_CAPABILITIES, agentSearchCapability, agentGetCapability, } from './discovery.js';
 export { ARTIFACT_CAPABILITIES, recordArtifactCapability, listArtifactsCapability, findArtifactsCapability, shareArtifactCapability, attachArtifactCapability, uploadArtifactUrlCapability, completeArtifactFileCapability, downloadArtifactCapability, reextractArtifactCapability, } from './artifacts.js';
 export { CHAT_CAPABILITIES, openConversationCapability, presentSendResult, } from './chat.js';
+export { EVERYDAY_MCP_TOOLS, EVERYDAY_DESTRUCTIVE_MCP, EVERYDAY_NO_SDK_TWIN, EVERYDAY_SDK_TOOLS, } from './everyday.js';
+export { annotationForSdkTool } from './toolLane.js';

package/dist/capabilities/toolLane.d.ts

@@ -0,0 +1,3 @@
+import type { CapabilityAnnotation } from './types.js';
+/** Annotation of a shared capability, by its SDK tool name. */
+export declare function annotationForSdkTool(name: string): CapabilityAnnotation | undefined;

package/dist/capabilities/toolLane.js

@@ -0,0 +1,39 @@
+import { AGREEMENT_CAPABILITIES } from './agreements.js';
+import { AGREEMENT_VERB_CAPABILITIES, LISTING_DOOR_CAPABILITIES, agreementSubcontractCapability, } from './agreementVerbs.js';
+import { ARTIFACT_CAPABILITIES } from './artifacts.js';
+import { CHAT_CAPABILITIES } from './chat.js';
+import { CONNECTION_CAPABILITIES } from './connections.js';
+import { CONTEXT_CAPABILITIES } from './context.js';
+import { DISCOVERY_CAPABILITIES } from './discovery.js';
+import { GRANTS_CAPABILITIES } from './grants.js';
+import { INTRODUCTION_CAPABILITIES } from './introductions.js';
+import { LINK_CAPABILITIES } from './links.js';
+import { MARKETPLACE_CAPABILITIES } from './marketplace.js';
+import { PAYMENT_CAPABILITIES } from './payments.js';
+import { TASK_CAPABILITIES } from './tasks.js';
+const CAPABILITIES = [
+    ...AGREEMENT_CAPABILITIES,
+    ...AGREEMENT_VERB_CAPABILITIES,
+    agreementSubcontractCapability,
+    ...LISTING_DOOR_CAPABILITIES,
+    ...ARTIFACT_CAPABILITIES,
+    ...CHAT_CAPABILITIES,
+    ...CONNECTION_CAPABILITIES,
+    ...CONTEXT_CAPABILITIES,
+    ...DISCOVERY_CAPABILITIES,
+    ...GRANTS_CAPABILITIES,
+    ...INTRODUCTION_CAPABILITIES,
+    ...LINK_CAPABILITIES,
+    ...MARKETPLACE_CAPABILITIES,
+    ...PAYMENT_CAPABILITIES,
+    ...TASK_CAPABILITIES,
+];
+const bySdkName = new Map();
+for (const cap of CAPABILITIES) {
+    if (!bySdkName.has(cap.names.sdk))
+        bySdkName.set(cap.names.sdk, cap.annotation);
+}
+/** Annotation of a shared capability, by its SDK tool name. */
+export function annotationForSdkTool(name) {
+    return bySdkName.get(name);
+}

package/dist/http/ChatClient.d.ts

@@ -13,9 +13,10 @@ import { type Creds } from '../types.js';
  * with without a second call.
  */
 export type ChatSummary = ChatReadDto;
-export declare function openConversation(participantId: string, creds: Creds, { newChat, agreementId }?: {
+export declare function openConversation(participantId: string, creds: Creds, { newChat, agreementId, createIfMissing }?: {
     newChat?: boolean;
     agreementId?: string;
+    createIfMissing?: boolean;
 }): Promise<{
     chatId: string;
     reused?: boolean;
@@ -34,9 +35,8 @@ export interface SendChatMessageInput {
     to?: string;
     /**
      * 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.
+     * receiver when Jev is confident. Otherwise it stores room context without
+     * a specific wake. Explicit addressing is required for a guaranteed target.
      */
     receiverId?: string;
     text: string;
@@ -47,7 +47,6 @@ export interface SendChatMessageInput {
     /** Governing service agreement; independent of representation. */
     conversationAgreementId?: string;
     taskId?: string;
-    replyToMessageId?: string;
 }
 /**
  * Where the server says a send landed.
@@ -122,6 +121,7 @@ export declare class ChatClient {
     open(participantId: string, opts?: {
         newChat?: boolean;
         agreementId?: string;
+        createIfMissing?: boolean;
     }): Promise<{
         chatId: string;
         reused?: boolean;

package/dist/http/ChatClient.js

@@ -10,7 +10,7 @@ function assertCreds(creds, op) {
     if (!creds?.agentId)
         throw new Error(`agentId is required for ${op}`);
 }
-export async function openConversation(participantId, creds, { newChat = false, agreementId } = {}) {
+export async function openConversation(participantId, creds, { newChat = false, agreementId, createIfMissing } = {}) {
     if (!participantId)
         throw new Error('participantId is required for openConversation');
     assertCreds(creds, 'open conversation');
@@ -22,6 +22,7 @@ export async function openConversation(participantId, creds, { newChat = false,
         body: JSON.stringify({
             participantId,
             ...(newChat ? { newChat: true } : {}),
+            ...(createIfMissing !== undefined ? { createIfMissing } : {}),
             ...(agreementId ? { agreementId } : {}),
         }),
     });
@@ -107,7 +108,6 @@ export async function sendChatMessage(input, creds) {
             underAgreementId: input.underAgreementId,
             conversationAgreementId: input.conversationAgreementId,
             taskId: input.taskId,
-            replyToMessageId: input.replyToMessageId,
         }),
     });
     if (!res.ok) {

package/dist/http/ContextGrantsClient.d.ts

@@ -96,6 +96,24 @@ export declare class ContextGrantsClient {
      */
     constructor(operatorKey: string, agentId?: string, baseUrl?: string);
     issueGrant(input: IssueContextGrantInput): Promise<GrantView>;
+    /** Request-only endpoint: a successful call must still have granted no access. */
+    requestAccess(input: {
+        scopeKind: 'artifact' | 'chat' | 'agreement' | 'task';
+        scopeId: string;
+        reason: string;
+        permission?: 'read' | 'reply';
+        temporal?: 'from-now' | 'from-start';
+        durationHours?: number;
+        chatId?: string;
+        ownerId?: string;
+    }, opts?: {
+        idempotencyKey?: string;
+        laneId?: string;
+    }): Promise<{
+        status: 'pending_approval';
+        agreementId: string;
+        accessGranted: false;
+    }>;
     requestArtifactAccess(artifactId: string, input: {
         chatId: string;
         ownerId: string;

package/dist/http/ContextGrantsClient.js

@@ -63,6 +63,25 @@ export class ContextGrantsClient {
         }
         return parsed.grant;
     }
+    /** Request-only endpoint: a successful call must still have granted no access. */
+    async requestAccess(input, opts) {
+        const res = await fetch(`${this.baseUrl}/context/access/requests`, {
+            method: 'POST',
+            headers: buildOperatorHeaders(this.operatorKey, this.agentId, {
+                'content-type': 'application/json',
+                ...(opts?.idempotencyKey ? { 'Idempotency-Key': opts.idempotencyKey } : {}),
+            }, opts?.laneId),
+            body: JSON.stringify(input),
+        });
+        const body = await res.text().catch(() => '');
+        if (!res.ok)
+            throwApiError(res, body, `requestAccess failed: ${res.status}`);
+        const result = JSON.parse(body);
+        if (result.status !== 'pending_approval' || !result.agreementId || result.accessGranted !== false) {
+            throw new Error('Expected a pending access request with accessGranted=false');
+        }
+        return { status: 'pending_approval', agreementId: result.agreementId, accessGranted: false };
+    }
     async requestArtifactAccess(artifactId, input, opts) {
         const res = await fetch(`${this.baseUrl}/context/artifacts/${encodeURIComponent(artifactId)}/access-requests`, {
             method: 'POST',

package/dist/http/ContextOpenClient.d.ts

@@ -32,6 +32,13 @@ export interface ContextOpenAccess {
     continuation?: {
         kind: 'owner_decision';
         summary: string;
+        request?: {
+            scopeKind: 'chat' | 'agreement' | 'task';
+            scopeId: string;
+            permission: 'read' | 'reply';
+            temporal: 'from-now' | 'from-start';
+            durationHours: number;
+        };
     };
 }
 export interface ContextOpenResult {

package/dist/http/ContextReadClient.d.ts

@@ -67,6 +67,15 @@ export interface ContextSnapshotResult {
         contentType: string;
         timestamp: string | null;
     }>;
+    /** Direct artifact grants missing from the room inventory. Id and name only. */
+    grantedArtifacts?: {
+        items: Array<{
+            artifactId: string;
+            name: string | null;
+            via: string;
+        }>;
+        omitted: number;
+    };
     agents: Array<ContextSnapshotParticipant & {
         agentId: string;
     }>;

package/dist/http/MarketplaceClient.d.ts

@@ -19,6 +19,11 @@ export interface PublishOfferPayload {
     billing?: 'total' | 'per_task';
     /** Broadcast audience: 'everyone' (default, fully public) or 'org' (members of your active org only). */
     audience?: BroadcastAudience;
+    /**
+     * How many customers may hold a live hire from this listing at once. A hire
+     * that ends gives its seat back. Omit for unlimited.
+     */
+    maxClaims?: number;
     metadata?: Record<string, unknown>;
     /**
      * Replay handle, sent as the `Idempotency-Key` header — the same way
@@ -29,6 +34,14 @@ export interface PublishOfferPayload {
     idempotencyKey?: string;
 }
 export declare function publishOffer(payload: PublishOfferPayload, creds: Creds): Promise<Agreement>;
+/**
+ * Stop taking new customers on a listing you publish, without deleting it. It
+ * leaves the board and claims on it are refused until you resume it; hires
+ * already sold keep running. The server refuses anyone but the publisher.
+ */
+export declare function pauseOffer(agreementId: string, creds: Creds): Promise<Agreement>;
+/** Reopen a paused listing: same row, same id, back on the board. */
+export declare function resumeOffer(agreementId: string, creds: Creds): Promise<Agreement>;
 export interface PullOffersOptions {
     limit?: number;
     since?: string;
@@ -47,6 +60,8 @@ export declare class MarketplaceClient {
      */
     constructor(operatorKey: string, agentId?: string);
     publishOffer(payload: PublishOfferPayload): Promise<Agreement>;
+    pauseOffer(agreementId: string): Promise<Agreement>;
+    resumeOffer(agreementId: string): Promise<Agreement>;
     pullOffers(options?: PullOffersOptions): Promise<Agreement[]>;
     pullRequests(options?: PullRequestsOptions): Promise<Agreement[]>;
 }

package/dist/http/MarketplaceClient.js

@@ -35,6 +35,33 @@ export async function publishOffer(payload, creds) {
     }
     return shapeAgreement(data['agreement']);
 }
+/**
+ * Stop taking new customers on a listing you publish, without deleting it. It
+ * leaves the board and claims on it are refused until you resume it; hires
+ * already sold keep running. The server refuses anyone but the publisher.
+ */
+export async function pauseOffer(agreementId, creds) {
+    return setOfferPaused(agreementId, 'pause', creds);
+}
+/** Reopen a paused listing: same row, same id, back on the board. */
+export async function resumeOffer(agreementId, creds) {
+    return setOfferPaused(agreementId, 'resume', creds);
+}
+async function setOfferPaused(agreementId, verb, creds) {
+    if (!agreementId)
+        throw new Error(`agreementId is required to ${verb} a listing`);
+    assertCreds(creds, `marketplace offer ${verb}`);
+    const res = await fetch(`${getMarketplaceBaseUrl()}/offers/${encodeURIComponent(agreementId)}/${verb}`, { method: 'POST', headers: buildHeaders(creds), body: JSON.stringify({}) });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throwApiError(res, body, `Marketplace offer ${verb} failed: ${res.status}`);
+    }
+    const data = await res.json().catch(() => null);
+    if (!data?.['agreement']) {
+        throw new Error(`Invalid response: expected { agreement } from POST /marketplace/offers/:id/${verb}`);
+    }
+    return shapeAgreement(data['agreement']);
+}
 export async function pullOffers(options, creds) {
     assertCreds(creds, 'marketplace offers pull');
     const params = new URLSearchParams();
@@ -87,6 +114,8 @@ export class MarketplaceClient {
         this.creds = { operatorKey, agentId };
     }
     publishOffer(payload) { return publishOffer(payload, this.creds); }
+    pauseOffer(agreementId) { return pauseOffer(agreementId, this.creds); }
+    resumeOffer(agreementId) { return resumeOffer(agreementId, this.creds); }
     pullOffers(options) { return pullOffers(options, this.creds); }
     pullRequests(options) { return pullRequests(options, this.creds); }
 }

package/dist/types.d.ts

@@ -244,6 +244,12 @@ export interface Agreement {
     } | null;
     /** Set on a link that was formed by claiming the invite with this id. */
     linkInviteTemplateId?: string | null;
+    /**
+     * When the publisher paused this listing, or null while it takes customers.
+     * Only a listing carries it; a paused listing refuses new claims until it is
+     * resumed, and hires already sold from it keep running.
+     */
+    listingPausedAt?: string | null;
     /**
      * the provider slot is FIXED (a hand-off): claiming or
      * approving this makes you the party the work is done FOR, not the worker —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/api-client",
-  "version": "0.23.1",
+  "version": "0.25.0",
   "description": "HTTP and WebSocket client for the Ziggs backend API",
   "type": "module",
   "main": "dist/index.js",