@ziggs-ai/api-client 0.30.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.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/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.1",
   "description": "HTTP and WebSocket client for the Ziggs backend API",
   "type": "module",
   "main": "dist/index.js",