@ziggs-ai/api-client 0.38.0 → 0.39.0

package/dist/http/MessageRecordsClient.js

@@ -0,0 +1,30 @@
+import { parseMessageCommand } from '@ziggs-ai/contracts';
+import { buildOperatorHeaders } from './operatorHeaders.js';
+import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
+/** One command and one representation, independent of navigation. */
+export class MessageRecordsClient {
+    operatorKey;
+    agentId;
+    baseUrl;
+    constructor(operatorKey, agentId, baseUrl) {
+        this.operatorKey = operatorKey;
+        this.agentId = agentId;
+        this.baseUrl = baseUrl;
+    }
+    async request(path, init = {}) { const res = await fetch(`${this.baseUrl ?? getBackendUrl()}/messaging/${path}`, { ...init, headers: { 'content-type': 'application/json', ...buildOperatorHeaders(this.operatorKey, this.agentId) } }); if (!res.ok)
+        throwApiError(res, await res.text().catch(() => ''), `Messaging failed: ${res.status}`); return await res.json(); }
+    async get(id) { const row = await this.request(`messages/${encodeURIComponent(id)}`); if (row.messageId !== id || !row.content || !Array.isArray(row.requestedAnswers))
+        throw new Error('Invalid exact message response'); return row; }
+    async send(command) { const result = await this.request('messages', { method: 'POST', body: JSON.stringify(parseMessageCommand(command)) }); if (!['created', 'existing'].includes(result.outcome) || !result.message?.messageId || !result.message.content || !Array.isArray(result.message.recipients) || !Array.isArray(result.message.requestedAnswers))
+        throw new Error('Invalid message command response'); return result; }
+    list(input = {}) { const query = new URLSearchParams(); for (const [key, value] of Object.entries(input))
+        if (value !== undefined)
+            query.set(key, Array.isArray(value) ? value.join(',') : String(value)); return this.request(`messages?${query}`); }
+    replies(id, input = {}) { const query = new URLSearchParams(); for (const [key, value] of Object.entries(input))
+        if (value !== undefined)
+            query.set(key, String(value)); return this.request(`messages/${encodeURIComponent(id)}/replies?${query}`); }
+    controls(agreementId, taskId) { const query = new URLSearchParams({ agreementId, ...(taskId ? { taskId } : {}) }); return this.request(`controls?${query}`); }
+    answers(id) { return this.request(`messages/${encodeURIComponent(id)}/answers`); }
+    cancelAnswer(id, requestId) { return this.request(`messages/${encodeURIComponent(id)}/answers/${encodeURIComponent(requestId)}/cancel`, { method: 'POST' }); }
+}

package/dist/http/SessionsClient.d.ts

@@ -8,11 +8,11 @@ export interface AssistantSessionRow {
     lastSeenAt: string;
     expiresAt: string;
     workspaceIds: string[];
-    heldChatIds: string[];
+    heldExecutionIds: string[];
     awake: boolean;
 }
 /**
- * List sibling windows and hold a chat in this one.
+ * List sibling windows and hold an execution in this one.
  * Uses the same session headers as the inbox so "this window" is the
  * X-Ziggs-Session the host already sends.
  */
@@ -23,12 +23,12 @@ export declare class SessionsClient {
     private url;
     list(): Promise<AssistantSessionRow[]>;
     /**
-     * Hold `chatId` in this window (omit sessionId; server resolves from
+     * Hold `executionContextId` in this window (omit sessionId; server resolves from
      * X-Ziggs-Session), move it to `sessionId`, or pass null to release.
      */
-    hold(chatId: string, sessionId?: string | null): Promise<{
+    hold(executionContextId: string, sessionId?: string | null): Promise<{
         success: true;
-        chatId: string;
+        executionContextId: string;
         sessionId: string | null;
     }>;
 }

package/dist/http/SessionsClient.js

@@ -2,7 +2,7 @@ import { getBackendUrl } from '../utils/urlUtils.js';
 import { pollSurfaceError } from '../shared/rateLimit.js';
 import { buildCredsHeaders } from './operatorHeaders.js';
 /**
- * List sibling windows and hold a chat in this one.
+ * List sibling windows and hold an execution in this one.
  * Uses the same session headers as the inbox so "this window" is the
  * X-Ziggs-Session the host already sends.
  */
@@ -48,14 +48,14 @@ export class SessionsClient {
         return Array.isArray(rows) ? rows : [];
     }
     /**
-     * Hold `chatId` in this window (omit sessionId; server resolves from
+     * Hold `executionContextId` in this window (omit sessionId; server resolves from
      * X-Ziggs-Session), move it to `sessionId`, or pass null to release.
      */
-    async hold(chatId, sessionId) {
-        if (!chatId?.trim())
-            throw new Error('SessionsClient.hold: chatId is required');
+    async hold(executionContextId, sessionId) {
+        if (!executionContextId?.trim())
+            throw new Error('SessionsClient.hold: executionContextId is required');
         const body = {
-            chatId: chatId.trim(),
+            executionContextId: executionContextId.trim(),
         };
         if (sessionId !== undefined)
             body.sessionId = sessionId;

package/dist/http/TaskClient.d.ts

@@ -1,3 +1,5 @@
+import { type TaskUpdateState } from '@ziggs-ai/contracts';
+export type { TaskUpdateState } from '@ziggs-ai/contracts';
 import type { WriteSource } from '../capabilities/sources.js';
 import { type Creds, type Task, type TaskState } from '../types.js';
 /**
@@ -5,6 +7,8 @@ import { type Creds, type Task, type TaskState } from '../types.js';
  * getTask / ziggs_task_get.
  */
 export interface TaskWriteConfirm {
+    success: true;
+    /** @deprecated Use success. */
     ok: true;
     taskId: string;
     /** The agreement the task hangs under, when the server reports it. */
@@ -84,7 +88,7 @@ export interface CreateTaskData {
      * server-side.
      */
     assigneeId?: string;
-    /** prior-step artifact handles consumed as structured input links. */
+    /** Required artifact handles; declaring them grants no access. */
     inputArtifactIds?: string[];
     /**
      * Tasks this one waits for. The task is created immediately, but its assignee
@@ -152,9 +156,8 @@ export interface UpdateTaskStateData {
     /** What the result drew on. Recorded only when a result is written. */
     sources?: WriteSource[];
 }
-export declare function updateTaskState(taskId: string, state: TaskState, data: UpdateTaskStateData | undefined, creds: Creds): Promise<TaskWriteConfirm>;
+export declare function updateTaskState(taskId: string, state: TaskUpdateState, data: UpdateTaskStateData | undefined, creds: Creds): Promise<TaskWriteConfirm>;
 export declare function getActiveTasksForAgent(agentId: string, creds: Creds): Promise<Task[]>;
-export declare function getActiveTasksForChat(chatId: string, creds: Creds): Promise<Task[]>;
 export declare function cancelTask(taskId: string, creds: Creds): Promise<TaskWriteConfirm>;
 export declare function getSubtasks(parentTaskId: string, creds: Creds): Promise<Task[]>;
 export interface PlanReplaceStep {
@@ -205,6 +208,8 @@ export interface ListTasksOptions {
     limit?: number;
     /** Filter to tasks assigned to this id. */
     assignedTo?: string;
+    /** Stored assignee, including tasks held by dependencies. */
+    assigneeId?: string;
     /**
      * Filter to tasks CREATED by this id — what the caller handed out, as
      * opposed to what was handed to it.
@@ -213,12 +218,14 @@ export interface ListTasksOptions {
 }
 export interface ListTasksResult {
     tasks: Task[];
+    /** Number of tasks on this page, not a total across pages. */
+    count: number;
     hasMore: boolean;
     nextCursor?: string | null;
 }
 export declare function listTasks(options: ListTasksOptions | undefined, creds: Creds): Promise<ListTasksResult>;
 export interface CountTasksFilters {
-    chatId?: string;
+    agreementId?: string;
     state?: string;
     userId?: string;
     agentId?: string;
@@ -237,9 +244,8 @@ export declare class TaskClient {
         children?: CreatedTaskChild[];
     }>;
     getTask(taskId: string): Promise<Task>;
-    updateTaskState(taskId: string, state: TaskState, data?: UpdateTaskStateData): Promise<TaskWriteConfirm>;
+    updateTaskState(taskId: string, state: TaskUpdateState, data?: UpdateTaskStateData): Promise<TaskWriteConfirm>;
     getActiveTasksForAgent(agentId: string): Promise<Task[]>;
-    getActiveTasksForChat(chatId: string): Promise<Task[]>;
     cancelTask(taskId: string): Promise<TaskWriteConfirm>;
     getSubtasks(parentTaskId: string): Promise<Task[]>;
     replaceTaskPlan(taskId: string, steps: PlanReplaceStep[]): Promise<TaskWriteConfirm>;
@@ -250,3 +256,26 @@ export declare class TaskClient {
     listTasks(options?: ListTasksOptions): Promise<ListTasksResult>;
     countTasks(filters?: CountTasksFilters): Promise<number>;
 }
+/** Controlled work transfer; the source execution header is preserved. */
+export declare function delegateTask(taskId: string, body: {
+    agreementId: string;
+    assigneeId: string;
+    instructionArtifactId: string;
+    inputArtifactIds?: string[];
+    idempotencyKey?: string;
+}, creds: Creds): Promise<{
+    taskId: string;
+    agreementId: string;
+    parentTaskId: string;
+}>;
+export declare function returnTaskResult(taskId: string, artifactId: string, creds: Creds): Promise<{
+    taskId: string;
+    parentTaskId: string;
+    artifactId: string;
+    outcome: 'created' | 'existing';
+}>;
+export declare function refreshTaskReadiness(taskId: string, creds: Creds): Promise<{
+    taskId: string;
+    ready: boolean;
+    state: string;
+}>;

package/dist/http/TaskClient.js

@@ -1,8 +1,9 @@
+import { TASK_UPDATE_STATES } from '@ziggs-ai/contracts';
 import { decodeOperatorKeyClaims } from '../shared/operatorKey.js';
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { partyActorIds } from '../types.js';
 import { throwApiError } from '../shared/apiError.js';
-import { buildCredsHeaders } from './operatorHeaders.js';
+import { buildCredsHeaders, withoutExecution } from './operatorHeaders.js';
 function getTaskBaseUrl() { return `${getBackendUrl()}/tasks`; }
 // Auth, agent and the wake's lane, from the one helper — see operatorHeaders.
 const buildHeaders = buildCredsHeaders;
@@ -38,7 +39,9 @@ async function writeTaskControl(taskId, path, method, body, creds) {
         throw new Error('Task control requires a taskId');
     assertCreds(creds, 'task control');
     const res = await fetch(`${getTaskBaseUrl()}/${encodeURIComponent(taskId)}/${path}`, {
-        method, headers: buildHeaders(creds), body: JSON.stringify(body),
+        // A quiescence receipt must remain possible after the task execution has
+        // been stopped. The server still checks executor identity and requestId.
+        method, headers: path === 'control/ack' ? withoutExecution(buildHeaders(creds)) : buildHeaders(creds), body: JSON.stringify(body),
     });
     if (!res.ok)
         throwApiError(res, await res.text().catch(() => ''), `Task control failed: ${res.status}`);
@@ -57,6 +60,7 @@ function extractWriteConfirm(data) {
         d['task'] === undefined &&
         d['description'] === undefined) {
         return {
+            success: true,
             ok: true,
             ...(d['control'] ? { control: d['control'] } : {}),
             taskId: d['taskId'],
@@ -84,6 +88,7 @@ function extractWriteConfirm(data) {
     if (!task?.taskId || !task.state)
         return null;
     return {
+        success: true,
         ok: true,
         taskId: task.taskId,
         state: task.state,
@@ -140,6 +145,9 @@ export async function updateTaskState(taskId, state, data = {}, creds) {
         throw new Error('updateTaskState: taskId is required');
     if (!state)
         throw new Error('updateTaskState: state is required');
+    if (!TASK_UPDATE_STATES.includes(state)) {
+        throw new Error('updateTaskState accepts active, completed or failed; use cancelTask to cancel');
+    }
     assertCreds(creds, 'task state update');
     const res = await fetch(`${getTaskBaseUrl()}/${taskId}/state`, {
         method: 'PATCH',
@@ -217,37 +225,6 @@ async function getActiveTasksForAgentViaPartyAgreements(agentId, creds) {
     const merged = lists.flat();
     return workable(merged.filter((t) => !t.assigneeId || t.assigneeId === agentId));
 }
-// Backend deliberately has no `/chats/:id/tasks` route — it's composable
-// from links → per-agreement tasks. We do the composition here so callers
-// don't have to.
-export async function getActiveTasksForChat(chatId, creds) {
-    if (!chatId)
-        throw new Error('getActiveTasksForChat: chatId is required');
-    assertCreds(creds, 'getting active tasks for chat');
-    const linksRes = await fetch(`${getBackendUrl()}/agreements/by-chat/${encodeURIComponent(chatId)}`, { method: 'GET', headers: buildHeaders(creds) });
-    if (!linksRes.ok) {
-        const body = await linksRes.text().catch(() => '');
-        throwApiError(linksRes, body, `Get agreements for chat failed: ${linksRes.status} ${linksRes.statusText}`);
-    }
-    const linksData = await linksRes.json().catch(() => null);
-    const rawLinks = linksData?.['links'] ?? linksData?.['agreements'];
-    const agreements = Array.isArray(rawLinks) ? rawLinks : [];
-    const agreementIds = Array.from(new Set(agreements.map((a) => a['agreementId']).filter(Boolean)));
-    if (agreementIds.length === 0)
-        return [];
-    const lists = await Promise.all(agreementIds.map(async (aid) => {
-        const url = new URL(`${getBackendUrl()}/agreements/${encodeURIComponent(aid)}/tasks`);
-        url.searchParams.set('state', 'active');
-        const res = await fetch(url.toString(), { method: 'GET', headers: buildHeaders(creds) });
-        if (!res.ok) {
-            const body = await res.text().catch(() => '');
-            throwApiError(res, body, `Get tasks for agreement ${aid} failed: ${res.status}`);
-        }
-        const data = await res.json().catch(() => null);
-        return Array.isArray(data?.['tasks']) ? data['tasks'] : [];
-    }));
-    return lists.flat();
-}
 export async function cancelTask(taskId, creds) {
     if (!taskId)
         throw new Error('cancelTask: taskId is required');
@@ -424,6 +401,8 @@ export async function listTasks(options = {}, creds) {
         url.searchParams.set('limit', String(options.limit));
     if (options.assignedTo)
         url.searchParams.set('assignedTo', options.assignedTo);
+    if (options.assigneeId)
+        url.searchParams.set('assigneeId', options.assigneeId);
     if (options.createdBy)
         url.searchParams.set('createdBy', options.createdBy);
     const res = await fetch(url.toString(), {
@@ -438,6 +417,7 @@ export async function listTasks(options = {}, creds) {
     const tasks = Array.isArray(data?.['tasks']) ? data['tasks'] : [];
     return {
         tasks,
+        count: tasks.length,
         hasMore: Boolean(data?.['hasMore']),
         nextCursor: data?.['nextCursor'] ?? null,
     };
@@ -446,8 +426,8 @@ export async function countTasks(filters = {}, creds) {
     assertCreds(creds, 'count tasks');
     // Canonical REST: GET /tasks/count.
     const url = new URL(`${getTaskBaseUrl()}/count`);
-    if (filters.chatId)
-        url.searchParams.set('chatId', filters.chatId);
+    if (filters.agreementId)
+        url.searchParams.set('agreementId', filters.agreementId);
     if (filters.state)
         url.searchParams.set('state', filters.state);
     if (filters.userId)
@@ -487,7 +467,6 @@ export class TaskClient {
     getTask(taskId) { return getTask(taskId, this.creds); }
     updateTaskState(taskId, state, data) { return updateTaskState(taskId, state, data ?? {}, this.creds); }
     getActiveTasksForAgent(agentId) { return getActiveTasksForAgent(agentId, this.creds); }
-    getActiveTasksForChat(chatId) { return getActiveTasksForChat(chatId, this.creds); }
     cancelTask(taskId) { return cancelTask(taskId, this.creds); }
     getSubtasks(parentTaskId) { return getSubtasks(parentTaskId, this.creds); }
     replaceTaskPlan(taskId, steps) { return replaceTaskPlan(taskId, steps, this.creds); }
@@ -498,3 +477,26 @@ export class TaskClient {
     listTasks(options) { return listTasks(options ?? {}, this.creds); }
     countTasks(filters) { return countTasks(filters, this.creds); }
 }
+/** Controlled work transfer; the source execution header is preserved. */
+export async function delegateTask(taskId, body, creds) {
+    const { idempotencyKey, ...payload } = body;
+    return taskTransfer(taskId, 'delegations', payload, creds, idempotencyKey);
+}
+export async function returnTaskResult(taskId, artifactId, creds) {
+    return taskTransfer(taskId, 'return', { artifactId }, creds);
+}
+export async function refreshTaskReadiness(taskId, creds) {
+    return taskTransfer(taskId, 'readiness', {}, creds);
+}
+async function taskTransfer(taskId, path, body, creds, key) {
+    assertCreds(creds, 'task transfer');
+    if (!taskId)
+        throw new Error('taskId is required');
+    const headers = buildHeaders(creds);
+    if (key)
+        headers['Idempotency-Key'] = key;
+    const res = await fetch(`${getTaskBaseUrl()}/${encodeURIComponent(taskId)}/${path}`, { method: 'POST', headers, body: JSON.stringify(body) });
+    if (!res.ok)
+        throwApiError(res, await res.text().catch(() => ''), `Task transfer failed: ${res.status}`);
+    return res.json();
+}

package/dist/http/agreementFlows.d.ts

@@ -1,4 +1,4 @@
-import { type ClaimedKind, type ClaimOptions, type ClaimRoom, type ProposeTerms } from './AgreementClient.js';
+import { type ClaimedKind, type ClaimOptions, type ProposeTerms } from './AgreementClient.js';
 import { type Agreement, type Creds, type EngagementKind } from '../types.js';
 /**
  * one propose grammar. Direct, broadcast (request and standing
@@ -13,7 +13,7 @@ import { type Agreement, type Creds, type EngagementKind } from '../types.js';
 export interface UnifiedProposeInput extends ProposeTerms {
     proposedTo: string;
     /** Required on direct proposals; optional on broadcasts/links. */
-    chatId?: string;
+    addressId?: string;
     engagementKind?: EngagementKind;
 }
 export type ProposeShape = 'direct' | 'request' | 'offer';
@@ -38,5 +38,4 @@ 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

@@ -2,7 +2,7 @@ import { claimAgreement, proposeBroadcast, proposeDirectTo, } from './AgreementC
 import { publishOffer } from './MarketplaceClient.js';
 import { isBroadcastTarget, } from '../types.js';
 export async function proposeUnified(input, creds) {
-    const { proposedTo, chatId, engagementKind, providerId, ...terms } = input;
+    const { proposedTo, addressId, engagementKind, providerId, ...terms } = input;
     if (!proposedTo)
         throw new Error('proposedTo is required (a user/agent id, or "everyone"/"org"/"company" to broadcast)');
     // The 'link' arm is gone. A link is not a proposal shape: it has no
@@ -34,7 +34,7 @@ export async function proposeUnified(input, creds) {
         // Buyer-broadcast: the claimer works, your side pays — an open request.
         const agreement = await proposeBroadcast({
             ...terms,
-            chatId: chatId ?? '',
+            addressId: addressId ?? '',
             engagementKind: engagementKind ?? 'service',
             audience,
         }, creds);
@@ -51,7 +51,7 @@ export async function proposeUnified(input, creds) {
         proposedTo,
         // Omitted rather than sent empty: an absent field says "no room", and an
         // empty string is one more fiction for the server to interpret.
-        ...(chatId ? { chatId } : {}),
+        ...(addressId ? { addressId } : {}),
         providerId: providerId?.trim() || proposedTo,
         engagementKind: engagementKind ?? 'service',
     }, creds);
@@ -74,8 +74,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, room } = await claimAgreement(agreementId, creds, opts);
+    const { agreement, kind } = 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', ...(room ? { room } : {}) };
+    return { agreement, kind: kind ?? 'request' };
 }

package/dist/http/index.d.ts

@@ -2,13 +2,10 @@ export * from './TaskClient.js';
 export * from './AgreementClient.js';
 export * from './MarketplaceClient.js';
 export * from './agreementFlows.js';
-export * from './ChatClient.js';
-export { MessagesClient, messagesListUrl } from './MessagesClient.js';
-export type { ListMessagesOptions, ListMessagesResult } from './MessagesClient.js';
-export { ArtifactsClient, artifactScopeForSession, AGREEMENT_LANE_PREFIX, ARTIFACT_INLINE_TEXT_MAX_CHARS, ARTIFACT_INLINE_TEXT_OVER_LIMIT_HINT, } from './ArtifactsClient.js';
+export { ArtifactsClient, artifactScope, AGREEMENT_LANE_PREFIX, ARTIFACT_INLINE_TEXT_MAX_CHARS, ARTIFACT_INLINE_TEXT_OVER_LIMIT_HINT, } from './ArtifactsClient.js';
 export type { ArtifactVisibility, ListArtifactsOptions, ListArtifactsQuery, ListArtifactsResult, WriteArtifactInput, } from './ArtifactsClient.js';
 export { ContextReadClient, CONTEXT_READ_TYPES, CONTEXT_READ_VIA, VIA_KINDS, parseVia, viaHint, } from './ContextReadClient.js';
-export type { ContextReadType, ContextReadQuery, ContextReadEnvelope, ContextSnapshotResult, ContextSnapshotParticipant, ViaKind, } from './ContextReadClient.js';
+export type { ContextReadType, ContextReadQuery, ContextReadEnvelope, ContextSnapshotResult, ContextSnapshotQuery, ContextSnapshotParticipant, ViaKind, } from './ContextReadClient.js';
 export { ContextOpenClient, CONTEXT_OPEN_KINDS } from './ContextOpenClient.js';
 export type { ContextOpenKind, ContextOpenOutcome, ContextOpenRef, ContextOpenBody, ResourceAction, ResourceActionCall, ContextOpenAccess, ContextOpenResult, ContextExplainResult, } from './ContextOpenClient.js';
 export { ContextDiscoveryClient } from './ContextDiscoveryClient.js';
@@ -37,3 +34,4 @@ export { planInboxAck, planPartialInboxAck, inboxAckAllowed, inboxAckHandledIds,
 export type { InboxAckDecision, InboxAckStep, InboxAckEnvelope, PlanInboxAckOptions, } from '../inboxAck.js';
 export { laneUnderAgreement, buildOperatorHeaders, buildCredsHeaders, } from './operatorHeaders.js';
 export { backendToolPick, type ToolPickOption, type ToolPickAnswer, type PickTool } from './ToolPickClient.js';
+export * from './MessageRecordsClient.js';

package/dist/http/index.js

@@ -2,11 +2,9 @@ export * from './TaskClient.js';
 export * from './AgreementClient.js';
 export * from './MarketplaceClient.js';
 export * from './agreementFlows.js';
-export * from './ChatClient.js';
-export { MessagesClient, messagesListUrl } from './MessagesClient.js';
 export { ArtifactsClient, 
-// agreement lanes are not chats — callers scope artifact writes with this.
-artifactScopeForSession, AGREEMENT_LANE_PREFIX, ARTIFACT_INLINE_TEXT_MAX_CHARS, ARTIFACT_INLINE_TEXT_OVER_LIMIT_HINT, } from './ArtifactsClient.js';
+// Artifact writes name their conversation or work; a lane is never one.
+artifactScope, AGREEMENT_LANE_PREFIX, ARTIFACT_INLINE_TEXT_MAX_CHARS, ARTIFACT_INLINE_TEXT_OVER_LIMIT_HINT, } from './ArtifactsClient.js';
 export { ContextReadClient, CONTEXT_READ_TYPES, CONTEXT_READ_VIA, VIA_KINDS, parseVia, viaHint, } from './ContextReadClient.js';
 export { ContextOpenClient, CONTEXT_OPEN_KINDS } from './ContextOpenClient.js';
 export { ContextDiscoveryClient } from './ContextDiscoveryClient.js';
@@ -28,3 +26,4 @@ export { planInboxAck, planPartialInboxAck, inboxAckAllowed, inboxAckHandledIds,
 // copy of a header nobody notices missing goes stale unseen.
 export { laneUnderAgreement, buildOperatorHeaders, buildCredsHeaders, } from './operatorHeaders.js';
 export { backendToolPick } from './ToolPickClient.js';
+export * from './MessageRecordsClient.js';

package/dist/http/operatorHeaders.d.ts

@@ -12,6 +12,9 @@ type AssistantHints = {
 };
 /** Node-only, opt-in request context. Ordinary HTTP clients remain browser-safe. */
 export declare function withAssistantRequest<T>(hints: AssistantHints, run: () => T): Promise<Awaited<T>>;
+/** Start an autonomous callback with no inherited execution, attempt or assistant hints.
+ * This is an entry boundary, never a retry of a refused scoped operation. */
+export declare function withAutonomousRequest<T>(run: () => T): Promise<Awaited<T>>;
 export declare function assistantRequestHeaders(): Record<string, string>;
 /** A presentation routing key; it carries no authority. */
 export declare function laneUnderAgreement(laneId: string, agreementId?: string | null): string;

package/dist/http/operatorHeaders.js

@@ -1,19 +1,26 @@
 let assistantRequest;
 let assistantContextLoading;
-/** Node-only, opt-in request context. Ordinary HTTP clients remain browser-safe. */
-export async function withAssistantRequest(hints, run) {
+async function requestContext() {
     assistantContextLoading ??= import('node:async_hooks').then(({ AsyncLocalStorage }) => {
         assistantRequest = new AsyncLocalStorage();
         return assistantRequest;
     });
-    const context = await assistantContextLoading;
-    // A workspace router adds its per-operation target inside the caller's
-    // session. Preserve that session without sharing it between concurrent calls.
+    return assistantContextLoading;
+}
+/** Node-only, opt-in request context. Ordinary HTTP clients remain browser-safe. */
+export async function withAssistantRequest(hints, run) {
+    const context = await requestContext();
     return await context.run({ ...context.getStore(), ...hints, orgId: hints.orgId, resource: hints.resource }, run);
 }
+/** Start an autonomous callback with no inherited execution, attempt or assistant hints.
+ * This is an entry boundary, never a retry of a refused scoped operation. */
+export async function withAutonomousRequest(run) {
+    return await (await requestContext()).run({}, run);
+}
 export function assistantRequestHeaders() {
     const hints = assistantRequest?.getStore();
     return {
+        ...(hints?.executionContext?.attemptId ? { 'X-Ziggs-Attempt': hints.executionContext.attemptId } : {}),
         ...((hints?.executionContextId ?? hints?.executionContext?.contextId) ? { 'X-Ziggs-Execution': (hints?.executionContextId ?? hints?.executionContext?.contextId) } : {}),
         ...(hints?.orgId ? { 'X-Workspace-Id': hints.orgId } : {}),
         ...(hints?.resource ? { 'X-Ziggs-Resource': hints.resource } : {}),
@@ -49,6 +56,8 @@ export function withoutExecution(headers) {
     const out = { ...headers };
     delete out['X-Ziggs-Execution'];
     delete out['x-ziggs-execution'];
+    delete out['X-Ziggs-Attempt'];
+    delete out['x-ziggs-attempt'];
     return out;
 }
 /** What a `Creds`-shaped client sends on a JSON call: auth, agent, lane. */

package/dist/inboxAck.d.ts

@@ -3,7 +3,7 @@ export interface InboxAckEnvelope {
     ackTo?: string | null;
     deliveries?: ReadonlyArray<{
         resourceId?: string | null;
-        responsibilityId?: string | null;
+        receiptId?: string | null;
         assigneeId?: string | null;
         outOfReach?: unknown;
         executionBlocked?: unknown;
@@ -12,7 +12,7 @@ export interface InboxAckEnvelope {
     }>;
     openRequestsAwaitingMe?: ReadonlyArray<{
         agreementId?: string | null;
-        responsibilityId?: string | null;
+        receiptId?: string | null;
         ts?: string | null;
     }>;
 }

package/dist/inboxAck.js

@@ -1,8 +1,8 @@
 export function inboxAckHandledIds(envelope, ownAgentId, ownAgentIds) {
     const mine = (id) => ownAgentIds ? ownAgentIds.includes(id ?? '') : ownAgentId ? id === ownAgentId : !!id;
     return [...new Set([
-            ...(envelope.deliveries ?? []).filter(d => mine(d.assigneeId) && !d.outOfReach && !d.executionBlocked).map(d => d.responsibilityId),
-            ...(envelope.openRequestsAwaitingMe ?? []).map(r => r.responsibilityId),
+            ...(envelope.deliveries ?? []).filter(d => mine(d.assigneeId) && !d.outOfReach && !d.executionBlocked).map(d => d.receiptId),
+            ...(envelope.openRequestsAwaitingMe ?? []).map(r => r.receiptId),
         ].filter((id) => !!id))];
 }
 export function inboxAckAllowed(envelope, opts = {}) {

package/dist/index.d.ts

@@ -13,8 +13,8 @@ export type { DelegateEnv, ResolvedDelegateCreds, } from './shared/delegateCreds
 export { RateLimitedError, isRateLimited, parseRetryAfterMs, pollSurfaceError, } from './shared/rateLimit.js';
 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, ClaimRoom, } from './http/AgreementClient.js';
+export type { Creds, Task, TaskState, PlanStep, PlanStepStatus, Agreement, AgreementParties, AgreementPartySide, EngagementKind, BroadcastAudience, EntryType, ContentType, InboxDeliveryKind, InboxDeliveryRef, InboxChatNews, InboxProposalRef, InboxTaskRef, InboxRequestRef, InboxPlanAckRef, InboxConnectionRequestRef, InboxHumanAttention, InboxEnvelope, InboxAckResult, InboxPeek, InboxReadOptions, } from './types.js';
+export type { ProposeTerms, ProposeDirectInput, ProposeBroadcastInput, ProposeAgreementData, ClaimOptions, } from './http/AgreementClient.js';
 export { decisionWords, speakableActor } from './decisionWords.js';
 export type { DecisionOutcome, DecisionWords, DecisionWordsInput, } from './decisionWords.js';
 export { planInboxAck, planPartialInboxAck, inboxAckAllowed, inboxAckHandledIds, } from './inboxAck.js';
@@ -31,9 +31,9 @@ export { inboxEngagement, isEchoOrDuplicate, isHireWorkOrder, contactPath, forma
 export type { EngagementGuide, EngagementGuideKind, EngagementOutcome, EngagementTaskHint, ContactPathInput, FormationInput, GraphHonesty, HireTermsHonesty, WaitingOn, } from './engagementGuide.js';
 export { isContextAccessRequest } from './shared/contextAccessRequest.js';
 export { AssistantConnectionClient, type AssistantWorkspace, type McpEventStatus, } from './http/AssistantConnectionClient.js';
-export { withAssistantRequest, assistantRequestHeaders } from './http/operatorHeaders.js';
+export { withAssistantRequest, withAutonomousRequest, assistantRequestHeaders } from './http/operatorHeaders.js';
 export { HANDLE_ALPHABET, findHandles, looksLikeHandle, parseHandle, parseRef, type HandleKind } from './handles.js';
 export { describeOperationError, type OperationError } from './shared/operationError.js';
 export { withWorkExecution, withWorkExecutionId, currentWorkExecution, withoutExecution } from './http/operatorHeaders.js';
 export { deliveryHandlingId, type WorkExecutionContext, type WorkPositionView } from '@ziggs-ai/contracts';
-export { validateWorkExecution } from './http/ExecutionContextClient.js';
+export { validateWorkExecution, prepareWorkExecution, runWorkExecution } from './http/ExecutionContextClient.js';

package/dist/index.js

@@ -28,10 +28,10 @@ export { sessionOrientation, } from './sessionOrientation.js';
 export { inboxEngagement, isEchoOrDuplicate, isHireWorkOrder, contactPath, formationGuide, marketplaceFormation, liveHireChangedTerms, liveHireConflictFromStatus, withdrawHeldGraph, reminderHonesty, graphReleaseHonesty, hintsFromTasks, } from './engagementGuide.js';
 export { isContextAccessRequest } from './shared/contextAccessRequest.js';
 export { AssistantConnectionClient, } from './http/AssistantConnectionClient.js';
-export { withAssistantRequest, assistantRequestHeaders } from './http/operatorHeaders.js';
+export { withAssistantRequest, withAutonomousRequest, assistantRequestHeaders } from './http/operatorHeaders.js';
 // Short handles: T…, A…, C…, F… (task, agreement, chat, artifact).
 export { HANDLE_ALPHABET, findHandles, looksLikeHandle, parseHandle, parseRef } from './handles.js';
 export { describeOperationError } from './shared/operationError.js';
 export { withWorkExecution, withWorkExecutionId, currentWorkExecution, withoutExecution } from './http/operatorHeaders.js';
 export { deliveryHandlingId } from '@ziggs-ai/contracts';
-export { validateWorkExecution } from './http/ExecutionContextClient.js';
+export { validateWorkExecution, prepareWorkExecution, runWorkExecution } from './http/ExecutionContextClient.js';