@ziggs-ai/api-client 0.37.1 → 0.37.4

package/dist/capabilities/chat.js

@@ -63,7 +63,7 @@ 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. 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"].',
+        sdk: 'Open a conversation or explicitly invite people to a room. participantId opens/reuses your person’s conversation with one person or agent, the same room each of their agents finds; newChat opens a separate subject, which can take a name. 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"].',
     },
     annotation: 'write',
     params: {
@@ -74,8 +74,8 @@ export const openConversationCapability = {
         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.' },
-        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.' },
+        name: { type: 'string', description: 'Name for a new group or a newChat room, 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.' },
+        createIfMissing: { type: 'boolean', description: 'Set false to reuse only an existing room with this 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 the named participants. ' +
@@ -108,8 +108,8 @@ export const openConversationCapability = {
         else if (args.chatId || args.idempotencyKey) {
             throw new Error('chatId and idempotencyKey require participantIds');
         }
-        if (typeof args.name === 'string' && args.name.trim() && !Array.isArray(args.participantIds)) {
-            throw new Error('A name is for a new group. Pair rooms take no name; the person is the name.');
+        if (typeof args.name === 'string' && args.name.trim() && !Array.isArray(args.participantIds) && args.newChat !== true) {
+            throw new Error('A name is for a new group or a newChat room. Pair rooms take no name; the person is the name.');
         }
         const { chatId, reused, invited, name } = await openConversation({
             ...(typeof args.participantId === 'string' ? { participantId: args.participantId } : {}),

package/dist/capabilities/context.js

@@ -430,13 +430,32 @@ function requestAccessAction(args, env) {
         requiresApproval: true,
     };
 }
+/** The readers an access request names: kinds stated, ids distinct, at most 20. */
+function readersOf(value) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 20)
+        throw new Error('holders must list 1 to 20 readers');
+    const seen = new Set();
+    return value.map((entry, i) => {
+        const kind = entry?.kind;
+        const id = entry?.id;
+        if (kind !== 'agent' && kind !== 'user' && kind !== 'org')
+            throw new Error(`holders[${i}].kind must be agent, user or org`);
+        if (typeof id !== 'string' || !id.trim())
+            throw new Error(`holders[${i}].id is required`);
+        const key = `${kind}:${id.trim()}`;
+        if (seen.has(key))
+            throw new Error(`holders names the same reader twice (holders[${i}])`);
+        seen.add(key);
+        return { kind, id: id.trim() };
+    });
+}
 export const accessRequestCapability = {
     key: 'access_request',
     names: { sdk: 'access_request', mcp: 'ziggs_access_request' },
-    title: 'Request access for yourself',
+    title: 'Request access for yourself or named readers',
     annotation: 'destructive', needsAgentId: true,
     descriptions: {
-        sdk: 'Request optional bounded access to one artifact, chat, agreement context or task. Creates only a pending approval; never grants access or approves. Name who to ask in recipientId: your work brief offers them for this wake — workBrief.actingFor.customer.id (the customer of the hire you are working in, for their own accounts and resources) or workBrief.actingFor.operator.id (your operator, for tools you bring). Anyone else is refused, and the refusal lists who you can ask. Artifact requests also need chatId, the conversation they approve in. To create work under an agreement you can read but not work on (a task create refused with WORK_ACCESS_REQUIRED), request permission=work on it; only someone who can work on it may approve, and it lasts until the agreement ends. Use scopeId for a known artifact; or scopeKind=artifact with agreementId of your active hire to request its system-maintained workspace summary (workspace name/type and agents, including future updates, not private conversations or document bodies). Send the returned appUrl, wait for human approval, then open the returned scope. Hiring alone grants no source access. Revocation and expiry are checked by the system.',
+        sdk: 'Request optional bounded access to one artifact, chat, agreement context or task. Creates only a pending approval; never grants access or approves. Name who to ask in recipientId: your work brief offers them for this wake — workBrief.actingFor.customer.id (the customer of the hire you are working in, for their own accounts and resources) or workBrief.actingFor.operator.id (your operator, for tools you bring). Anyone else is refused, and the refusal lists who you can ask. Artifact requests also need chatId, the conversation they approve in. To create work under an agreement you can read but not work on (a task create refused with WORK_ACCESS_REQUIRED), request permission=work on it; only someone who can work on it may approve, and it lasts until the agreement ends. Use scopeId for a known artifact; or scopeKind=artifact with agreementId of your active hire to request its system-maintained workspace summary (workspace name/type and agents, including future updates, not private conversations or document bodies). Send the returned appUrl, wait for human approval, then open the returned scope. To arrange reading of one artifact for others, name them in holders (agents by id, people or workspaces by id or the participant reference this room shows you); include yourself only if you need to read it too. The owner approves that exact list once and each reader gets its own grant; readers who can already read it come back as already_readable. Hiring alone grants no source access. Revocation and expiry are checked by the system.',
     },
     params: {
         scopeKind: { type: 'string', required: true, enum: ['artifact', 'chat', 'agreement', 'task'] },
@@ -451,6 +470,18 @@ export const accessRequestCapability = {
         // comes back refused with the people this agent may ask. Required in the
         // schema, a host refused the call before that list could arrive.
         recipientId: { type: 'string', description: 'Who to ask: workBrief.actingFor.customer.id (the customer of this hire) or workBrief.actingFor.operator.id (your operator). Without it, the refusal lists who you can ask.' },
+        holders: {
+            type: 'array',
+            description: 'Artifact only, read only: up to 20 readers, each { kind: "agent" | "user" | "org", id }. Leave yourself out to arrange it for others. Omit to ask for yourself.',
+            items: {
+                type: 'object',
+                properties: {
+                    kind: { type: 'string', enum: ['agent', 'user', 'org'] },
+                    id: { type: 'string' },
+                },
+                required: ['kind', 'id'],
+            },
+        },
         idempotencyKey: { type: 'string', description: 'Reuse for the same logical request' },
     },
     handler: async (args, env) => {
@@ -477,14 +508,26 @@ export const accessRequestCapability = {
         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 holders = args.holders === undefined ? undefined : readersOf(args.holders);
+        if (holders && (scopeKind !== 'artifact' || agreementId || permission !== 'read'))
+            throw new Error('holders is for one artifact named by scopeId, to read');
         const creds = fullCreds(env);
         const result = await new ContextGrantsClient(creds.operatorKey, creds.agentId, env.baseUrl).requestAccess({
             scopeKind, scopeId, agreementId, reason: String(args.reason).trim(),
             permission: permission, temporal: args.temporal,
             durationHours, chatId: args.chatId,
             recipientId: typeof args.recipientId === 'string' ? args.recipientId.trim() : undefined,
+            ...(holders ? { holders } : {}),
         }, { idempotencyKey: args.idempotencyKey, laneId: creds.laneId });
         const actingAgentId = result.actingAgentId ?? (creds.agentId || undefined);
+        if (result.status === 'already_readable') {
+            return {
+                ...result, outcome: 'already_readable', state: 'not_requested',
+                ...(actingAgentId ? { actingAgentId } : {}),
+                scope: result.scope ?? { kind: scopeKind, id: scopeId },
+                note: result.message ?? 'Every reader you named can already read it. Nothing was asked.',
+            };
+        }
         return {
             ...result, outcome: 'pending', state: 'requested',
             ...(actingAgentId ? { actingAgentId } : {}),

package/dist/capabilities/mcpBriefs.js

@@ -21,11 +21,11 @@ const BRIEFS = {
         },
     },
     ziggs_inbox: {
-        does: 'Reads your inbox: deliveries oldest first, tasks, decisions, sessionChatCard; waitSeconds holds for news. Observes only: no claim or ack.',
+        does: 'Reads your inbox: deliveries by recipient, tasks, decisions, sessionChatCard; waitSeconds holds for news. Observes only: no claim or ack.',
         returns: 'a readPlan of next calls; backlog if more is unread',
         next: 'ziggs_inbox_claim to handle them',
         compact: {
-            does: 'Reads your inbox: deliveries oldest first, tasks, decisions, sessionChatCard; waitSeconds holds for news.',
+            does: 'Reads your inbox: deliveries by recipient, tasks, decisions, sessionChatCard; waitSeconds holds for news.',
             changes: 'takes or renews this host’s lease',
             next: 'ziggs_inbox_ack after handling',
         },

package/dist/http/ContextGrantsClient.d.ts

@@ -109,19 +109,12 @@ export declare class ContextGrantsClient {
         ownerId?: string;
         /** Who to ask, from the people the server offers this wake. */
         recipientId?: string;
+        /** Artifact only: who should read it, if not only the caller. One grant each. */
+        holders?: AccessReader[];
     }, opts?: {
         idempotencyKey?: string;
         laneId?: string;
-    }): Promise<{
-        status: 'pending_approval';
-        agreementId: string;
-        accessGranted: false;
-        actingAgentId?: string;
-        scope?: {
-            kind: string;
-            id: string;
-        };
-    } & RequestSentTo>;
+    }): Promise<AccessRequestResult>;
     requestArtifactAccess(artifactId: string, input: {
         chatId: string;
         ownerId: string;
@@ -167,6 +160,31 @@ export declare class ContextGrantsClient {
     }>;
 }
 /** Who got a request card and where they answer it, as the server says. */
+/** One reader an artifact access request asks for, named with its kind. */
+export interface AccessReader {
+    kind: 'agent' | 'user' | 'org';
+    id: string;
+}
+/** What a request did for one named reader. */
+export interface AccessReaderOutcome extends AccessReader {
+    outcome: 'already_readable' | 'awaiting_approval';
+}
+export type AccessRequestResult = {
+    accessGranted: false;
+    actingAgentId?: string;
+    scope?: {
+        kind: string;
+        id: string;
+    };
+    /** Per named reader, when the request named readers. */
+    readers?: AccessReaderOutcome[];
+} & RequestSentTo & ({
+    status: 'pending_approval';
+    agreementId: string;
+} | {
+    status: 'already_readable';
+    agreementId: null;
+});
 export interface RequestSentTo {
     sentTo?: {
         id: string;

package/dist/http/ContextGrantsClient.js

@@ -77,10 +77,22 @@ export class ContextGrantsClient {
         if (!res.ok)
             throwApiError(res, body, `requestAccess failed: ${res.status}`);
         const result = JSON.parse(body);
+        const readers = Array.isArray(result.readers) ? { readers: result.readers } : {};
+        const common = {
+            accessGranted: false,
+            ...(typeof result.actingAgentId === 'string' && result.actingAgentId ? { actingAgentId: result.actingAgentId } : {}),
+            ...(result.scope ? { scope: result.scope } : {}),
+            ...readers,
+            ...sentToOf(result),
+        };
+        // Every named reader already reads it: nothing was asked.
+        if (result.status === 'already_readable' && result.accessGranted === false) {
+            return { status: 'already_readable', agreementId: null, ...common };
+        }
         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, ...(typeof result.actingAgentId === 'string' && result.actingAgentId ? { actingAgentId: result.actingAgentId } : {}), ...(result.scope ? { scope: result.scope } : {}), ...sentToOf(result) };
+        return { status: 'pending_approval', agreementId: result.agreementId, ...common };
     }
     async requestArtifactAccess(artifactId, input, opts) {
         const res = await fetch(`${this.baseUrl}/context/artifacts/${encodeURIComponent(artifactId)}/access-requests`, {

package/dist/http/grants.d.ts

@@ -36,16 +36,8 @@ export type GrantBasisKind = 'creation' | 'publication' | 'membership' | 'accept
  * stopped showing a whole scope kind after `artifact` was added; anything that
  * means "every context scope" should read this.
  */
-export declare const CONTEXT_GRANT_SCOPE_KINDS: readonly ["chat", "agreement", "org", "artifact", "task"];
-/**
- * Every scope kind across every rail: context + connection + payment + consent
- * + carrier. Mirrors the server's `GRANT_SCOPE_KINDS` (grants/grant-view.ts),
- * which is the list `GET /grants?scopeKind=` validates against — a kind missing
- * here cannot be asked for at all, which is the failure the comment above
- * describes.
- */
-export declare const GRANT_SCOPE_KINDS: readonly ["chat", "agreement", "org", "artifact", "task", "connection", "wallet", "consent", "inbox"];
-export type GrantScopeKind = (typeof GRANT_SCOPE_KINDS)[number];
+import { CONTEXT_GRANT_SCOPE_KINDS, GRANT_SCOPE_KINDS, type ContextGrantScopeKind, type GrantScopeKind } from '@ziggs-ai/contracts';
+export { CONTEXT_GRANT_SCOPE_KINDS, GRANT_SCOPE_KINDS, type ContextGrantScopeKind, type GrantScopeKind, };
 /**
  * The scope a grant is over, and one caveat on it — the wire's shapes.
  *

package/dist/http/grants.js

@@ -6,32 +6,8 @@
  * stopped showing a whole scope kind after `artifact` was added; anything that
  * means "every context scope" should read this.
  */
-export const CONTEXT_GRANT_SCOPE_KINDS = [
-    'chat',
-    'agreement',
-    'org',
-    // narrowest context scope
-    'artifact',
-    // a branch of a work graph: the named task and everything under it, now and
-    // in future. Holding one is what being in a job means.
-    'task',
-];
-/**
- * Every scope kind across every rail: context + connection + payment + consent
- * + carrier. Mirrors the server's `GRANT_SCOPE_KINDS` (grants/grant-view.ts),
- * which is the list `GET /grants?scopeKind=` validates against — a kind missing
- * here cannot be asked for at all, which is the failure the comment above
- * describes.
- */
-export const GRANT_SCOPE_KINDS = [
-    ...CONTEXT_GRANT_SCOPE_KINDS,
-    'connection',
-    'wallet',
-    // approval authority — who may answer a slot
-    'consent',
-    // carrier grants — who reads whose mailbox
-    'inbox',
-];
+import { CONTEXT_GRANT_SCOPE_KINDS, GRANT_SCOPE_KINDS, } from '@ziggs-ai/contracts';
+export { CONTEXT_GRANT_SCOPE_KINDS, GRANT_SCOPE_KINDS, };
 /** Value of the first caveat of `type` on a grant, or undefined. */
 export function grantCaveat(grant, type) {
     return grant.caveats.find((c) => c.type === type)?.value;

package/dist/inboxAck.d.ts

@@ -8,7 +8,6 @@
  */
 export interface InboxAckEnvelope {
     ackTo?: string | null;
-    truncatedRequests?: number | null;
     deliveries?: ReadonlyArray<{
         resourceId?: string | null;
         assigneeId?: string | null;

package/dist/inboxAck.js

@@ -31,8 +31,6 @@ export function inboxAckHandledIds(envelope, ownAgentId, ownAgentIds) {
 export function inboxAckAllowed(envelope, opts = {}) {
     if (!envelope.ackTo)
         return false;
-    if ((envelope.truncatedRequests ?? 0) !== 0)
-        return false;
     const failures = opts.failures ?? 0;
     if (failures > 0 && !opts.forceAck)
         return false;
@@ -80,8 +78,6 @@ function gatingRows(envelope, ownAgentId, ownAgentIds) {
  * backend is handled: the caller keeps its single end-of-pass ack.
  */
 export function planPartialInboxAck(envelope, handled, opts = {}) {
-    if ((envelope.truncatedRequests ?? 0) !== 0)
-        return null;
     const failures = opts.failures ?? 0;
     if (failures > 0 && !opts.forceAck)
         return null;

package/dist/types.d.ts

@@ -1,6 +1,4 @@
-import type { AgreementPartySide, AgreementParties, PrincipalPresentation, InboxDeliveryRef } from '@ziggs-ai/contracts';
-import type { InboxRequestChannel } from '@ziggs-ai/contracts';
-import type { InboxPartyKind } from '@ziggs-ai/contracts';
+import { AGREEMENT_ENGAGEMENT_KIND, BROADCAST_TARGETS, OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET, isBroadcastTarget, partyActorIds, partySideIds, type AgreementPartySide, type AgreementParties, type AgreementStatusValue, type BroadcastAudience, type InboxDeliveryRef, type InboxPartyKind, type InboxRequestChannel, type PrincipalPresentation, type TaskStateValue } from '@ziggs-ai/contracts';
 /**
  * One failure shape for every HTTP client path.
  *
@@ -60,7 +58,7 @@ export interface Creds {
     /** Person-readable window name, sent as `X-Ziggs-Session-Name`. */
     sessionName?: string;
 }
-export type TaskState = 'active' | 'proposal' | 'completed' | 'failed' | 'cancelled' | 'ledger_open';
+export type TaskState = TaskStateValue;
 export type PlanStepStatus = 'pending' | 'in_progress' | 'completed' | 'skipped';
 export interface PlanStep {
     stepId: string;
@@ -139,15 +137,9 @@ export interface Task {
     payerIsYou?: boolean;
     proposedToIsYou?: boolean;
 }
-export type AgreementStatus = 'pending' | 'active' | 'fulfilled' | 'cancelled' | 'rejected' | (string & {});
+export type AgreementStatus = AgreementStatusValue;
 export type ProposalStatus = 'pending' | 'approved' | 'rejected' | 'countered' | 'expired' | (string & {});
-/** ⚠️ Mirrors the server's engagement-kind constant; the server is authoritative. */
-export declare const AGREEMENT_ENGAGEMENT_KIND: {
-    readonly HIRE: "hire";
-    readonly SERVICE: "service";
-    /** a bilateral reach link between two agents (no money, no work). */
-    readonly LINK: "link";
-};
+export { AGREEMENT_ENGAGEMENT_KIND, BROADCAST_TARGETS, OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET, isBroadcastTarget, partyActorIds, partySideIds, type BroadcastAudience, };
 export type EngagementKind = (typeof AGREEMENT_ENGAGEMENT_KIND)[keyof typeof AGREEMENT_ENGAGEMENT_KIND];
 /**
  * One side of an agreement, as the wire carries it.
@@ -161,15 +153,6 @@ export type EngagementKind = (typeof AGREEMENT_ENGAGEMENT_KIND)[keyof typeof AGR
 export type { AgreementPartySide };
 /** The four sides of an agreement, each {@link AgreementPartySide}. */
 export type { AgreementParties };
-/** Both ids on one side, principal first, absent ones dropped. */
-export declare function partySideIds(side: AgreementPartySide | null | undefined): string[];
-/**
- * Every agent that acted on this agreement, deduped.
- *
- * The read for "is this agent a party?" — an agent id lives in `actor` alone,
- * so widening the match to `principal` would hit an unrelated estate.
- */
-export declare function partyActorIds(parties: AgreementParties | null | undefined): string[];
 /** Compact agreement reference carried by task reads. */
 export interface AgreementSummary {
     agreementId: string;
@@ -289,7 +272,6 @@ export declare const EntryTypes: {
     readonly TASK_HISTORY: "task_history";
 };
 export type EntryType = (typeof EntryTypes)[keyof typeof EntryTypes];
-/** ⚠️ Mirrors the server's content-type constant; the server is authoritative. */
 export declare const ContentTypes: {
     readonly TEXT: "text";
     readonly OPERATION: "operation";
@@ -297,24 +279,13 @@ export declare const ContentTypes: {
     readonly RESULT: "result";
     readonly AGREEMENT_UPDATE: "agreement_update";
     readonly TASK: "task";
-    readonly PROPOSAL: "proposal";
+    readonly TASK_PLAN_STEP: "task_plan_step";
     readonly THOUGHT: "thought";
-    /** @deprecated legacy alias for AGREEMENT_UPDATE */
-    readonly TASK_UPDATE: "task_update";
+    readonly PROPOSAL: "proposal";
 };
 export type ContentType = (typeof ContentTypes)[keyof typeof ContentTypes];
 /** ⚠️ Mirrors the server's entry/content-type validation; the server is authoritative. */
 export declare function isValidContentType(contentType: string, entryType: string): boolean;
-/** ⚠️ Mirrors the server's sentinel. Fully-public broadcast target. */
-export declare const OPEN_AGREEMENT_TARGET: "everyone";
-/** ⚠️ Mirrors the server's sentinel. Org-scoped broadcast: visible/claimable only by members of the agreement's orgId. */
-export declare const ORG_AGREEMENT_TARGET: "org";
-/** Audience for a broadcast proposal: fully public ('everyone') or org-scoped ('org'). */
-export type BroadcastAudience = typeof OPEN_AGREEMENT_TARGET | typeof ORG_AGREEMENT_TARGET;
-/** Both broadcast sentinels — values that occupy a party slot but are NOT real principal ids. */
-export declare const BROADCAST_TARGETS: readonly ["everyone", "org"];
-/** True when `id` is a broadcast sentinel ('everyone' | 'org') rather than a concrete principal id. */
-export declare function isBroadcastTarget(id: string | null | undefined): boolean;
 export { isPersonaFaceRef as isPersonaRef, isRoomBindingRef as isRoomPresentationRef, isPresentationRef as isOpaquePresentationRef, } from '@ziggs-ai/contracts';
 /** Display + entitlement face for a principal on the message/roster wire. */
 export type { PrincipalPresentation };

package/dist/types.js

@@ -1,3 +1,4 @@
+import { AGREEMENT_ENGAGEMENT_KIND, BROADCAST_TARGETS, MESSAGE_CONTENT_TYPE, OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET, isBroadcastTarget, partyActorIds, partySideIds, } from '@ziggs-ai/contracts';
 /**
  * One failure shape for every HTTP client path.
  *
@@ -27,32 +28,7 @@ export class RateLimitedError extends ApiError {
         this.retryAfterMs = retryAfterMs;
     }
 }
-/** ⚠️ Mirrors the server's engagement-kind constant; the server is authoritative. */
-export const AGREEMENT_ENGAGEMENT_KIND = {
-    HIRE: 'hire',
-    SERVICE: 'service',
-    /** a bilateral reach link between two agents (no money, no work). */
-    LINK: 'link',
-};
-/** The four sides, in the order every fan-out walks them. */
-const AGREEMENT_PARTY_SIDES = ['payer', 'provider', 'proposedTo', 'creator'];
-/** Both ids on one side, principal first, absent ones dropped. */
-export function partySideIds(side) {
-    return [side?.principal, side?.actor].filter((id) => typeof id === 'string' && id.length > 0);
-}
-/**
- * Every agent that acted on this agreement, deduped.
- *
- * The read for "is this agent a party?" — an agent id lives in `actor` alone,
- * so widening the match to `principal` would hit an unrelated estate.
- */
-export function partyActorIds(parties) {
-    // The wire always sends all four sides; a caller may still hand us nothing.
-    const p = parties ?? {};
-    return [
-        ...new Set(AGREEMENT_PARTY_SIDES.map((name) => p[name]?.actor).filter((id) => typeof id === 'string' && id.length > 0)),
-    ];
-}
+export { AGREEMENT_ENGAGEMENT_KIND, BROADCAST_TARGETS, OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET, isBroadcastTarget, partyActorIds, partySideIds, };
 /** ⚠️ Mirrors the server's entry-type constant; the server is authoritative. */
 export const EntryTypes = {
     MESSAGE: 'message',
@@ -62,38 +38,28 @@ export const EntryTypes = {
     /** @deprecated legacy alias for AGREEMENT_HISTORY */
     TASK_HISTORY: 'task_history',
 };
-/** ⚠️ Mirrors the server's content-type constant; the server is authoritative. */
-export const ContentTypes = {
-    TEXT: 'text',
-    OPERATION: 'operation',
-    CONTEXT: 'context',
-    RESULT: 'result',
-    AGREEMENT_UPDATE: 'agreement_update',
-    TASK: 'task',
-    PROPOSAL: 'proposal',
-    THOUGHT: 'thought',
-    /** @deprecated legacy alias for AGREEMENT_UPDATE */
-    TASK_UPDATE: 'task_update',
-};
+export const ContentTypes = MESSAGE_CONTENT_TYPE;
 const VALID_CONTENT_TYPES = {
     [EntryTypes.MESSAGE]: [ContentTypes.TEXT],
-    [EntryTypes.NOTIFICATION]: [ContentTypes.TEXT, ContentTypes.TASK, ContentTypes.PROPOSAL],
-    [EntryTypes.ARTIFACT]: [ContentTypes.OPERATION, ContentTypes.CONTEXT, ContentTypes.RESULT, ContentTypes.TEXT, ContentTypes.THOUGHT],
-    [EntryTypes.AGREEMENT_HISTORY]: [ContentTypes.AGREEMENT_UPDATE, ContentTypes.TASK_UPDATE],
-    [EntryTypes.TASK_HISTORY]: [ContentTypes.AGREEMENT_UPDATE, ContentTypes.TASK_UPDATE],
+    [EntryTypes.NOTIFICATION]: [
+        ContentTypes.TEXT,
+        ContentTypes.TASK,
+        ContentTypes.TASK_PLAN_STEP,
+        ContentTypes.PROPOSAL,
+        ContentTypes.AGREEMENT_UPDATE,
+    ],
+    [EntryTypes.ARTIFACT]: [
+        ContentTypes.OPERATION,
+        ContentTypes.CONTEXT,
+        ContentTypes.RESULT,
+        ContentTypes.TEXT,
+        ContentTypes.THOUGHT,
+    ],
+    [EntryTypes.AGREEMENT_HISTORY]: [ContentTypes.AGREEMENT_UPDATE],
+    [EntryTypes.TASK_HISTORY]: [ContentTypes.AGREEMENT_UPDATE],
 };
 /** ⚠️ Mirrors the server's entry/content-type validation; the server is authoritative. */
 export function isValidContentType(contentType, entryType) {
     return VALID_CONTENT_TYPES[entryType]?.includes(contentType) ?? false;
 }
-/** ⚠️ Mirrors the server's sentinel. Fully-public broadcast target. */
-export const OPEN_AGREEMENT_TARGET = 'everyone';
-/** ⚠️ Mirrors the server's sentinel. Org-scoped broadcast: visible/claimable only by members of the agreement's orgId. */
-export const ORG_AGREEMENT_TARGET = 'org';
-/** Both broadcast sentinels — values that occupy a party slot but are NOT real principal ids. */
-export const BROADCAST_TARGETS = [OPEN_AGREEMENT_TARGET, ORG_AGREEMENT_TARGET];
-/** True when `id` is a broadcast sentinel ('everyone' | 'org') rather than a concrete principal id. */
-export function isBroadcastTarget(id) {
-    return id === OPEN_AGREEMENT_TARGET || id === ORG_AGREEMENT_TARGET;
-}
 export { isPersonaFaceRef as isPersonaRef, isRoomBindingRef as isRoomPresentationRef, isPresentationRef as isOpaquePresentationRef, } from '@ziggs-ai/contracts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/api-client",
-  "version": "0.37.1",
+  "version": "0.37.4",
   "description": "HTTP and WebSocket client for the Ziggs backend API",
   "type": "module",
   "main": "dist/index.js",
@@ -27,7 +27,7 @@
     "test:watch": "node --import tsx/esm --test --watch test/*.test.ts"
   },
   "dependencies": {
-    "@ziggs-ai/contracts": "^0.21.0",
+    "@ziggs-ai/contracts": "^0.23.3",
     "socket.io-client": "^4.7.0"
   },
   "keywords": [