@ziggs-ai/api-client 0.30.0 → 0.30.2

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.js

@@ -3,13 +3,13 @@ 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
@@ -52,16 +52,14 @@ function presentClaim(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 } : {}),
         };
@@ -70,11 +68,7 @@ function presentClaim(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 } : {}),
     };

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
@@ -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.
@@ -133,7 +137,10 @@ export const openConversationCapability = {
                         : '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 } : {}),
@@ -141,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) {

package/dist/capabilities/context.js

@@ -408,7 +408,7 @@ export const accessRequestCapability = {
     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.',
+        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, or form a generic work agreement to recover missing access.',
     },
     annotation: 'write', needsAgentId: true,
     params: {

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;

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.30.0",
+  "version": "0.30.2",
   "description": "HTTP and WebSocket client for the Ziggs backend API",
   "type": "module",
   "main": "dist/index.js",