@ziggs-ai/api-client 0.29.0 → 0.30.1

package/dist/capabilities/agreementVerbs.js

@@ -424,6 +424,9 @@ export const agreementHandoffCapability = {
         // would have had to look it up to pass it, and a lookup whose answer is
         // unique is not a decision worth handing to the caller.
         const parent = await getAgreement(parentAgreementId, creds);
+        if (typeof parent?.publishedService !== 'boolean') {
+            throw new Error('Service publishing requires an updated server. No proposal was sent.');
+        }
         const providerId = parent?.parties?.provider?.actor;
         if (!providerId) {
             throw new Error(`Cannot hand off ${parentAgreementId}: it names no provider, so there is no hire to share. Check the id with agreement_get.`);
@@ -435,8 +438,8 @@ export const agreementHandoffCapability = {
         };
         const to = args['to'];
         const agreement = to
-            ? await proposeDirectTo({ ...terms, proposedTo: to, chatId: '', providerId, engagementKind: 'hire' }, creds)
-            : await proposeBroadcast({ ...terms, chatId: '', audience: 'everyone', providerId, engagementKind: 'hire' }, creds);
+            ? await proposeDirectTo({ ...terms, proposedTo: to, chatId: '', useParentProvider: true, engagementKind: 'hire' }, creds)
+            : await proposeBroadcast({ ...terms, chatId: '', audience: 'everyone', useParentProvider: true, engagementKind: 'hire' }, creds);
         return { agreement, ...(to ? {} : { readPlan: publishedNext(env) }) };
     },
     sdkOptions: { isAgreementCreation: true },

package/dist/capabilities/agreements.d.ts

@@ -1,4 +1,4 @@
-import type { ClaimedKind } from '../http/AgreementClient.js';
+import type { ClaimedKind, ClaimRoom } from '../http/AgreementClient.js';
 import type { Agreement } from '../types.js';
 import { type NextCallOutcome, type WorkContext } from './nextCall.js';
 import { type CapabilityDefinition, type CapabilityEnv } from './types.js';
@@ -7,12 +7,13 @@ import { type CapabilityDefinition, type CapabilityEnv } from './types.js';
  * return `{agreement, kind}` while MCP returned `{status, kind, message,
  * agreement}` — same HTTP call, two answers.
  */
-export declare function presentClaimResult(agreement: Agreement, kind: ClaimedKind, env: CapabilityEnv): {
+export declare function presentClaimResult(agreement: Agreement, kind: ClaimedKind, env: CapabilityEnv, room?: ClaimRoom): {
     status: string;
     outcome: NextCallOutcome;
     kind: ClaimedKind;
     message: string;
     agreement: Agreement;
+    room?: ClaimRoom;
     workContext?: WorkContext;
 };
 /**

package/dist/capabilities/agreements.js

@@ -3,20 +3,41 @@ import { claimOpenAgreement } from '../http/agreementFlows.js';
 import { linkIsReachOnly, webAppOrigin } from './links.js';
 import { workContextFromEnv } from './nextCall.js';
 import { fullCreds } from './types.js';
-/** Which side the claimer just took, for a claim that has not activated yet. */
-function claimedWhat(kind) {
+/** Plain outcome once the hire is active. `kind` stays on the result, not in this sentence. */
+function activeHireMessage(kind) {
     if (kind === 'offer')
-        return 'Standing offer claimed — the publisher provides, your side pays.';
+        return 'The hire is active. They do the work.';
     if (kind === 'hand-off')
-        return 'Hand-off claimed — the pinned agent works FOR you.';
-    return 'Request claimed — you provide the work.';
+        return 'The hire is active. Their agent works for you.';
+    return 'The hire is active. You do the work.';
 }
 /**
  * One claim result shape for both surfaces. The SDK protocol runner used to
  * return `{agreement, kind}` while MCP returned `{status, kind, message,
  * agreement}` — same HTTP call, two answers.
  */
-export function presentClaimResult(agreement, kind, env) {
+export function presentClaimResult(agreement, kind, env, room) {
+    const out = presentClaim(agreement, kind, env);
+    if (!room)
+        return out;
+    return { ...out, message: `${out.message} ${roomWords(room)}`, room };
+}
+/**
+ * The room the hire was made in, in words. "Ready" is said only
+ * when the agent is in; a failure says the hire and its charge stand and names
+ * the call that resumes admission.
+ */
+function roomWords(room) {
+    if (room.status === 'ready') {
+        return `The agent is in room ${room.chatId} now.`;
+    }
+    if (room.status === 'awaiting_approval') {
+        return `Once it is approved, the agent joins room ${room.chatId} with no further step; the room shows the proposal to the person who can answer it.`;
+    }
+    const retry = room.recovery ? ` Resume with ${room.recovery.method} ${room.recovery.path}.` : '';
+    return `The hire is active, but the agent is not in room ${room.chatId} yet${room.message ? ` (${room.message})` : ''}. Do not claim again.${retry}`;
+}
+function presentClaim(agreement, kind, env) {
     const workContext = workContextFromEnv(env);
     if (kind === 'link') {
         return {
@@ -31,16 +52,14 @@ export function presentClaimResult(agreement, kind, env) {
     if (agreement?.status !== 'active') {
         const held = (agreement?.approvals ?? []).find((a) => a.status === 'pending');
         const approveUrl = agreementAppUrl(webAppOrigin(env), agreement.agreementId);
-        const remedy = held?.heldReason === 'contact-basis'
-            ? 'This is a first engagement with that counterparty — your human approves once; a standing link covers it after that.'
-            : 'Claiming for a job your human already approved activates at once — name the job with mandateAgreementId.';
+        const stranger = held?.heldReason === 'contact-basis'
+            ? ' This is a first engagement with that counterparty — your human approves once; a standing link covers it after that.'
+            : '';
         return {
             status: 'pending_approval',
             outcome: 'pending',
             kind,
-            message: `${claimedWhat(kind)} It is not active yet: the formation is waiting on ` +
-                'human approval, so nothing can be created under it until that lands. ' +
-                `Your human can approve it here: ${approveUrl} — ${remedy}`,
+            message: `Hire requested. Waiting for your yes: ${approveUrl}.${stranger}`,
             agreement,
             ...(workContext ? { workContext } : {}),
         };
@@ -49,11 +68,7 @@ export function presentClaimResult(agreement, kind, env) {
         status: 'claimed',
         outcome: 'ok',
         kind,
-        message: kind === 'offer'
-            ? 'Standing offer claimed — the publisher provides, your side pays. Spawn work under it with the task-create tool.'
-            : kind === 'hand-off'
-                ? 'Hand-off claimed — the pinned agent works FOR you: you are the customer (and the payer when priced), never the worker. Spawn work under it with the task-create tool.'
-                : 'Request claimed — you provide the work. Read the terms, then post progress and set the task result under this agreement.',
+        message: activeHireMessage(kind),
         agreement,
         ...(workContext ? { workContext } : {}),
     };
@@ -68,8 +83,8 @@ export const agreementClaimCapability = {
     names: { sdk: 'agreement_claim', mcp: 'ziggs_agreement_claim' },
     title: 'Claim a posted agreement',
     descriptions: {
-        sdk: 'Claim an open broadcast agreement by id — the DEFAULT way to engage: terms are already posted, consent is the claim and there are no negotiation turns. Claims a request (you do the work, the publisher pays), a standing offer (you buy, the publisher works), a hand-off (providerPinned: the publisher\'s hired agent works FOR you — you become the customer, and the payer when it is priced), or a link invite (bilateral trust forms immediately). You become the open party. It activates at once when you can consent for your own side — an agent claiming help for a job it is already doing should name that job with mandateAgreementId; without it the formation waits on your human before anything can be spawned under it. A hand-off is claimable only after its provider has accepted (409 until then). Find requests/offers with marketplace_view; listings are take-it-or-leave-it — never counter one. Direct proposals are approved with agreement_respond instead, not claimed.',
-        mcp: 'Claim an open broadcast agreement by id — the DEFAULT way to engage: terms are already posted, consent is the claim and there are no negotiation turns. Claims a request (you do the work, the publisher pays), a standing offer (you buy, the publisher works), a hand-off (providerPinned: the publisher\'s hired agent works FOR you — you become the customer, and the payer when it is priced), or a link invite (bilateral trust forms immediately). You become the open party. It activates at once when you can consent for your own side — an agent claiming help for a job it is already doing should name that job with mandateAgreementId; without it the formation waits on your human before anything can be spawned under it. A hand-off is claimable only after its provider has accepted (409 until then). Find requests/offers with ziggs_marketplace_view; listings are take-it-or-leave-it — never counter one. Direct proposals are approved with ziggs_agreement_respond instead, not claimed. You cannot claim your own broadcast.',
+        sdk: 'Claim an open broadcast agreement by id — the DEFAULT way to engage: terms are already posted, consent is the claim and there are no negotiation turns. Claims a request (you do the work, the publisher pays), a standing offer (you buy, the publisher works), a hand-off (providerPinned: the publisher\'s hired agent works FOR you — you become the customer, and the payer when it is priced), or a link invite (bilateral trust forms immediately). You become the open party. It activates at once when you can consent for your own side — an agent claiming help for a job it is already doing should name that job with mandateAgreementId; without it the formation waits on your human before anything can be spawned under it. A hand-off is claimable only after its provider has accepted (409 until then). Find requests/offers with marketplace_view; listings are take-it-or-leave-it — never counter one. Direct proposals are approved with agreement_respond instead, not claimed. To hire an agent into a room, claim its listing with that room\'s chatId.',
+        mcp: 'Claim an open broadcast agreement by id — the DEFAULT way to engage: terms are already posted, consent is the claim and there are no negotiation turns. Claims a request (you do the work, the publisher pays), a standing offer (you buy, the publisher works), a hand-off (providerPinned: the publisher\'s hired agent works FOR you — you become the customer, and the payer when it is priced), or a link invite (bilateral trust forms immediately). You become the open party. It activates at once when you can consent for your own side — an agent claiming help for a job it is already doing should name that job with mandateAgreementId; without it the formation waits on your human before anything can be spawned under it. A hand-off is claimable only after its provider has accepted (409 until then). Find requests/offers with ziggs_marketplace_view; listings are take-it-or-leave-it — never counter one. Direct proposals are approved with ziggs_agreement_respond instead, not claimed. You cannot claim your own broadcast. To hire an agent into a room, claim its listing with that room\'s chatId.',
     },
     annotation: 'write',
     params: {
@@ -88,12 +103,16 @@ export const agreementClaimCapability = {
             type: 'string',
             description: 'The active agreement whose work this claim is part of — the job you are doing. Claiming for a job your human already approved needs no second approval from them, but you have to name the job: the server checks you are a party to it, and a wrong name simply earns nothing. Leave it out when the claim belongs to no job.',
         },
+        chatId: {
+            type: 'string',
+            description: 'The room this hire is for — only when claiming an agent\'s listing. When the hire activates the agent joins that exact room, with no invitation and no second approval; if it waits for a yes, the room shows it as a proposal. You must be in the room. The answer\'s room.status says where it stands.',
+        },
     },
     needsAgentId: true,
     handler: async (args, env) => {
         const declaredMandate = args['mandateAgreementId'];
-        const { agreement, kind } = await claimOpenAgreement(args['agreementId'], fullCreds(env), { ...(typeof declaredMandate === 'string' && declaredMandate ? { mandateAgreementId: declaredMandate } : {}), ...(typeof args['parentAgreementId'] === 'string' ? { parentAgreementId: args['parentAgreementId'] } : {}) });
-        return presentClaimResult(agreement, kind, env);
+        const { agreement, kind, room } = await claimOpenAgreement(args['agreementId'], fullCreds(env), { ...(typeof declaredMandate === 'string' && declaredMandate ? { mandateAgreementId: declaredMandate } : {}), ...(typeof args['parentAgreementId'] === 'string' ? { parentAgreementId: args['parentAgreementId'] } : {}), ...(typeof args['chatId'] === 'string' && args['chatId'] ? { chatId: args['chatId'] } : {}) });
+        return presentClaimResult(agreement, kind, env, room);
     },
 };
 export const AGREEMENT_CAPABILITIES = [agreementClaimCapability];

package/dist/capabilities/chat.js

@@ -1,5 +1,7 @@
 import { openConversation } from '../http/ChatClient.js';
+import { chatAppUrl } from '../utils/appUrls.js';
 import { fullCreds } from './types.js';
+import { webAppOrigin } from './links.js';
 import { workContextFromEnv } from './nextCall.js';
 /**
  * Present a send as what it is: a message that now exists, addressed to
@@ -54,8 +56,8 @@ export const openConversationCapability = {
     names: { sdk: 'chat_open', mcp: 'ziggs_chat_open' },
     title: 'Start or reuse a conversation',
     descriptions: {
-        sdk: 'Open a conversation or explicitly invite people to a room. participantId opens/reuses the acting agent’s pair conversation with one person or agent; newChat opens a separate subject. participantIds creates a separate group with the acting caller and those people; include a stable idempotencyKey for retries. chatId plus participantIds invites people into that exact room, requiring room access and admission authority. Every person needs a valid contact basis: shared organization membership, a link, or an applicable agreement. Each participant keeps their own agent and work relationships; opening a group selects no service agreement. Group creation never expands an existing private DM. Invited teammates read from admission onward. A new group is opened with people. With chatId, participantIds may also name agents: each joins through the same admission as the web app, so it must be reachable (your own, one of your company, published, or already engaged), and an agent you invite waits until the people in the room approve it in the app; the result lists each id as added, already-here or pending. Your own missing seat is asked for with access_request. Reach another person through their user id, not an unpublished agent of theirs. If you cannot reach someone your person knows, ask your person to introduce you in a room. Opening does not send a message; chat_send must name its intended receiverId to guarantee a target. To list accessible rooms, use grant_list with scopeKind ["chat"].',
-        mcp: 'Open a conversation or explicitly invite people to a room. participantId opens/reuses the acting agent’s pair conversation with one person or agent; newChat opens a separate subject. participantIds creates a separate group with the acting caller and those people; include a stable idempotencyKey for retries. chatId plus participantIds invites people into that exact room, requiring room access and admission authority. Every person needs a valid contact basis: shared organization membership, a link, or an applicable agreement. Each participant keeps their own agent and work relationships; opening a group selects no service agreement. Group creation never expands an existing private DM. Invited teammates read from admission onward. A new group is opened with people. With chatId, participantIds may also name agents: each joins through the same admission as the web app, so it must be reachable (your own, one of your company, published, or already engaged), and an agent you invite waits until the people in the room approve it in the app; the result lists each id as added, already-here or pending. Your own missing seat is asked for with ziggs_access_request. Reach another person through their user id, not an unpublished agent of theirs. For missing access to a known room, use ziggs_access_request; opening another room does not recover its history. Opening does not send a message; ziggs_chat_send must name its intended receiverId to guarantee a target.',
+        sdk: 'Open a conversation or explicitly invite people to a room. participantId opens/reuses the acting agent’s pair conversation with one person or agent; newChat opens a separate subject. participantIds creates a separate group with the acting caller and those people; include a stable idempotencyKey for retries. chatId plus participantIds invites people into that exact room, requiring room access and admission authority. Every person needs a valid contact basis: shared organization membership, a link, or an applicable agreement. Each participant keeps their own agent and work relationships; opening a group selects no service agreement. Group creation never expands an existing private DM. Invited teammates read from admission onward. participantIds may name agents, when creating a group or inviting into one: each must be reachable (your own, one of your company, published, or already engaged). An agent you add joins at once if your person gave you approval authority; otherwise it is a proposal in the room, and the first person in the room to say yes admits it. The result lists each id as added, already-here or pending. To bring in an agent you would hire, claim its listing with the room\'s chatId instead. Your own missing seat is asked for with access_request. Reach another person through their user id, not an unpublished agent of theirs. If you cannot reach someone your person knows, ask your person to introduce you in a room. Opening does not send a message; chat_send must name its intended receiverId to guarantee a target. To list accessible rooms, use grant_list with scopeKind ["chat"].',
+        mcp: 'Open a conversation or explicitly invite people to a room. participantId opens/reuses the acting agent’s pair conversation with one person or agent; newChat opens a separate subject. participantIds creates a separate group with the acting caller and those people; include a stable idempotencyKey for retries. chatId plus participantIds invites people into that exact room, requiring room access and admission authority. Every person needs a valid contact basis: shared organization membership, a link, or an applicable agreement. Each participant keeps their own agent and work relationships; opening a group selects no service agreement. Group creation never expands an existing private DM. Invited teammates read from admission onward. participantIds may name agents, when creating a group or inviting into one: each must be reachable (your own, one of your company, published, or already engaged). An agent you add joins at once if your person gave you approval authority; otherwise it is a proposal in the room, and the first person in the room to say yes admits it. The result lists each id as added, already-here or pending. To bring in an agent you would hire, claim its listing with the room\'s chatId instead. Your own missing seat is asked for with ziggs_access_request. Reach another person through their user id, not an unpublished agent of theirs. For missing access to a known room, use ziggs_access_request; opening another room does not recover its history. Opening does not send a message; ziggs_chat_send must name its intended receiverId to guarantee a target.',
     },
     annotation: 'write',
     params: {
@@ -63,7 +65,7 @@ export const openConversationCapability = {
             type: 'string',
             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.',
         },
-        participantIds: { type: 'array', items: { type: 'string' }, description: '1–20 known ids. Without chatId: people, for a separate group. With chatId: people or agents to invite into that room (an agent waits for the room\'s people to approve). Use instead of participantId. Each invitation is authorized separately.' },
+        participantIds: { type: 'array', items: { type: 'string' }, description: '1–20 known ids. With or without chatId, people and agents; an agent without your approval authority waits for one person in the room to say yes. Use instead of participantId. Each invitation is authorized separately.' },
         chatId: { type: 'string', description: 'Existing room to invite participantIds into. Never creates another room. Omit creation options and agreementId.' },
         idempotencyKey: { type: 'string', description: 'Required for group creation: a unique key for this conversation, reused unchanged on retries. A different participant set needs a new key.' },
         name: { type: 'string', description: 'Name for a new group, 1–80 characters. Pair rooms and team channels take no name. A retry of the same idempotencyKey keeps the first name. Rename later is PATCH /chats/:chatId by someone who can admit people.' },
@@ -113,6 +115,8 @@ export const openConversationCapability = {
             ...(typeof args.agreementId === 'string' && args.agreementId ? { agreementId: args.agreementId } : {}),
             ...(typeof args.name === 'string' && args.name.trim() ? { name: args.name.trim() } : {}),
         }, fullCreds(env));
+        const agentId = fullCreds(env).agentId;
+        const { people, pending } = roomRoster(args, invited, agentId);
         const lister = env.surface === 'mcp' ? 'ziggs_grant_list' : 'grant_list';
         const grantNote = `Use ${lister} with scopeKind ["chat"] to inspect your room grants. Opening a conversation does not send a message or confirm that anyone has read it.`;
         // word the note from the outcome instead of covering both cases.
@@ -120,16 +124,23 @@ export const openConversationCapability = {
         // withheld it — worse than silence, because the agent cannot even tell
         // there is something to look up. A backend too old to report it keeps the
         // old both-cases wording, and `reused` is simply absent from the result.
+        // A new group that named agents reports each of them too.
+        const created = reused === false ? 'Created a new conversation with the named participants, so there is no history to catch up on.' : null;
         const outcomeNote = args.chatId
             ? inviteNote(invited)
-            : reused === true
-                ? 'Reused the conversation you already had with the named participants, so it may already hold history — read it before you speak.'
-                : reused === false
-                    ? 'Created a new conversation with the named participants, so there is no history to catch up on.'
-                    : 'Conversation is open (or reused).';
+            : created && invited?.length
+                ? `${created} ${inviteNote(invited)}`
+                : reused === true
+                    ? 'Reused the conversation you already had with the named participants, so it may already hold history — read it before you speak.'
+                    : reused === false
+                        ? 'Created a new conversation with the named participants, so there is no history to catch up on.'
+                        : 'Conversation is open (or reused).';
         return {
             chatId,
-            actingAgentId: fullCreds(env).agentId,
+            appUrl: chatAppUrl(webAppOrigin(env), chatId),
+            actingAgentId: agentId,
+            people,
+            pending,
             ...(typeof reused === 'boolean' ? { reused } : {}),
             ...(name ? { name } : {}),
             ...(invited ? { invited } : {}),
@@ -137,6 +148,19 @@ export const openConversationCapability = {
         };
     },
 };
+/** Ids this open knows are in the room, and ids still waiting for approval. */
+function roomRoster(args, invited, agentId) {
+    const named = Array.isArray(args.participantIds)
+        ? args.participantIds.filter((id) => typeof id === 'string' && id.trim().length > 0).map((id) => id.trim())
+        : typeof args.participantId === 'string' && args.participantId.trim()
+            ? [args.participantId.trim()]
+            : [];
+    const pending = (invited ?? []).filter((row) => row.status === 'pending').map((row) => row.id);
+    const waiting = new Set(pending);
+    const here = (invited ?? []).filter((row) => row.status !== 'pending').map((row) => row.id);
+    const people = [...new Set([...named.filter((id) => !waiting.has(id)), ...here, agentId])];
+    return { people, pending };
+}
 /** Say what happened to each invited id, so the agent reports it truthfully. */
 function inviteNote(invited) {
     if (!invited?.length) {
@@ -149,7 +173,7 @@ function inviteNote(invited) {
     if (ids('already-here').length)
         parts.push(`Already in the room: ${ids('already-here').join(', ')}.`);
     if (ids('pending').length) {
-        parts.push(`Waiting for the people in the room to approve: ${ids('pending').join(', ')}. They see it in the app; the agent cannot read or write here until then, and asking again does not make a second request.`);
+        parts.push(`Proposed in the room, waiting for one person there to say yes: ${ids('pending').join(', ')}. The first answer decides; the agent cannot read or write here until then, and asking again does not make a second request.`);
     }
     return `${parts.join(' ')} Invited people read from now on.`;
 }

package/dist/http/AgreementClient.d.ts

@@ -31,6 +31,8 @@ export interface ProposeTerms {
      * side — there is no payer input.
      */
     providerId?: string;
+    /** Resolve the authorized active parent hire's provider on the server. */
+    useParentProvider?: boolean;
     /** Defaults to `service` on the server when omitted. Set `hire` for representation contracts. */
     engagementKind?: EngagementKind;
     idempotencyKey?: string;
@@ -318,11 +320,31 @@ export interface ClaimOptions {
      * verifies the claim against the acting agent and never guesses one.
      */
     mandateAgreementId?: string;
+    /**
+     * The room a hire of a listing is made in. On activation its
+     * agent joins that room; the claimer must take part in it.
+     */
+    chatId?: string;
+}
+/**
+ * Where a hire made in a room stands on getting its agent in.
+ * `ready` only once the agent is in; `admission_failed` names the action that
+ * resumes it without hiring or charging again.
+ */
+export interface ClaimRoom {
+    chatId: string;
+    status: 'awaiting_approval' | 'ready' | 'admission_failed';
+    message?: string;
+    recovery?: {
+        method: string;
+        path: string;
+    };
 }
 export declare function claimAgreement(agreementId: string, creds: Creds, opts?: ClaimOptions): Promise<{
     ok: boolean;
     agreement: Agreement;
     kind?: ClaimedKind;
+    room?: ClaimRoom;
 }>;
 /**
  * Link types a caller may ask for. `origin` and `delegation` are workflow-owned;
@@ -367,6 +389,7 @@ export declare class AgreementClient {
         ok: boolean;
         agreement: Agreement;
         kind?: ClaimedKind;
+        room?: ClaimRoom;
     }>;
     linkToChat(id: string, chatId: string, linkType?: ChatLinkType): Promise<unknown>;
     listChats(id: string): Promise<unknown[]>;

package/dist/http/AgreementClient.js

@@ -553,7 +553,7 @@ export async function claimAgreement(agreementId, creds, opts = {}) {
     const res = await fetch(`${getAgreementBaseUrl()}/${encodeURIComponent(agreementId)}/claim`, {
         method: 'POST',
         headers: buildHeaders(creds),
-        body: JSON.stringify({ ...(opts.mandateAgreementId ? { mandateAgreementId: opts.mandateAgreementId } : {}), ...(opts.parentAgreementId ? { parentAgreementId: opts.parentAgreementId } : {}) }),
+        body: JSON.stringify({ ...(opts.mandateAgreementId ? { mandateAgreementId: opts.mandateAgreementId } : {}), ...(opts.parentAgreementId ? { parentAgreementId: opts.parentAgreementId } : {}), ...(opts.chatId ? { chatId: opts.chatId } : {}) }),
     });
     if (!res.ok) {
         const body = await res.text().catch(() => '');

package/dist/http/agreementFlows.d.ts

@@ -1,4 +1,4 @@
-import { type ClaimedKind, type ClaimOptions, type ProposeTerms } from './AgreementClient.js';
+import { type ClaimedKind, type ClaimOptions, type ClaimRoom, type ProposeTerms } from './AgreementClient.js';
 import { type Agreement, type Creds, type EngagementKind } from '../types.js';
 /**
  * one propose grammar. Direct, broadcast (request and standing
@@ -38,4 +38,5 @@ export declare function proposeUnified(input: UnifiedProposeInput, creds: Creds)
 export declare function claimOpenAgreement(agreementId: string, creds: Creds, opts?: ClaimOptions): Promise<{
     agreement: Agreement;
     kind: ClaimedKind;
+    room?: ClaimRoom;
 }>;

package/dist/http/agreementFlows.js

@@ -75,8 +75,8 @@ export async function proposeUnified(input, creds) {
 export async function claimOpenAgreement(agreementId, creds, opts = {}) {
     if (!agreementId)
         throw new Error('agreementId is required');
-    const { agreement, kind } = await claimAgreement(agreementId, creds, opts);
+    const { agreement, kind, room } = await claimAgreement(agreementId, creds, opts);
     // A server that has not shipped the `kind` field yet still claims correctly;
     // 'request' is the shape the route has always handled.
-    return { agreement, kind: kind ?? 'request' };
+    return { agreement, kind: kind ?? 'request', ...(room ? { room } : {}) };
 }

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { RateLimitedError, isRateLimited, parseRetryAfterMs, pollSurfaceError, }
 export { parseErrorMessage, parseErrorCode, throwApiError, } from './shared/apiError.js';
 export { ApiError } from './types.js';
 export type { Creds, Task, TaskState, PlanStep, PlanStepStatus, Agreement, AgreementParties, AgreementPartySide, EngagementKind, BroadcastAudience, EntryType, ContentType, MessageMetadata, MessageHandler, InboxDeliveryKind, InboxDeliveryRef, InboxChatNews, InboxProposalRef, InboxTaskRef, InboxRequestRef, InboxConnectionRequestRef, InboxHumanAttention, InboxEnvelope, InboxAckResult, InboxPeek, InboxReadOptions, } from './types.js';
-export type { ProposeTerms, ProposeDirectInput, ProposeBroadcastInput, ProposeAgreementData, ClaimOptions, } from './http/AgreementClient.js';
+export type { ProposeTerms, ProposeDirectInput, ProposeBroadcastInput, ProposeAgreementData, ClaimOptions, ClaimRoom, } from './http/AgreementClient.js';
 export { decisionWords } from './decisionWords.js';
 export type { DecisionOutcome, DecisionWords, DecisionWordsInput, } from './decisionWords.js';
 export { planInboxAck, planPartialInboxAck, inboxAckAllowed, inboxAckHandledIds, } from './inboxAck.js';

package/dist/types.d.ts

@@ -176,6 +176,7 @@ export interface AgreementApprovalEntry {
     heldReason?: string | null;
 }
 export interface Agreement {
+    publishedService?: boolean;
     approvalAction?: {
         state: 'available' | 'needs_decision' | 'unavailable';
         partyId?: string;

package/dist/utils/appUrls.d.ts

@@ -1,6 +1,7 @@
 /** Resolve the app origin once for SDK, MCP, and capability links. */
 export declare function resolveWebAppOrigin(webUrl?: string | null, backendUrl?: string): string;
 export declare function agreementAppUrl(origin: string, id: string): string;
+export declare function chatAppUrl(origin: string, id: string): string;
 export declare function agreementsListAppUrl(origin: string): string;
 export declare function connectInviteAppUrl(origin: string, id: string): string;
 export declare function connectionsSettingsAppUrl(origin: string, requestId?: string | null): string;

package/dist/utils/appUrls.js

@@ -21,6 +21,9 @@ function appUrl(origin, path) {
 export function agreementAppUrl(origin, id) {
     return appUrl(origin, `/app/agreements/${encodeURIComponent(id)}`);
 }
+export function chatAppUrl(origin, id) {
+    return appUrl(origin, `/app/chat/${encodeURIComponent(id)}`);
+}
 export function agreementsListAppUrl(origin) {
     return appUrl(origin, '/app/agreements');
 }

package/package.json

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