@ziggs-ai/agent-sdk 0.41.2 → 0.42.2

package/CHANGELOG.md

@@ -32,6 +32,8 @@
 
 ## Unreleased
 
+- Expose the shared `task_delegate` capability on the hosted agent surface for recursive task assignments and approved artifact returns.
+
 ## 0.41.2
 
 ## 0.41.1

package/dist/Agent.d.ts

@@ -1,3 +1,4 @@
+import { type WorkExecutionContext } from '@ziggs-ai/api-client';
 import type { PollBinding, PollKind } from './platform/polls/PollKind.js';
 export { workScopeFromWake } from './runtime/wakeEffects.js';
 import type { AgentConfig, Ctx, Workflow } from './types.js';
@@ -212,6 +213,7 @@ export interface WakeRecord {
     agentId: string;
     sessionId: string;
     laneKey: string;
+    executionContext?: WorkExecutionContext;
     /** The event frame that woke the agent. */
     event: unknown;
     /** FSM context carried into the tick — undefined on a cold lane. */
@@ -298,6 +300,12 @@ export declare class Agent {
     private carryExecutionState;
     /** Runtime control is a task fact, never model-interpreted message text. */
     private taskExecutionControl;
+    /**
+     * Control on an assignment the inbox will not run yet. No wake follows, so a
+     * resume is acknowledged here too once no run of the task is live; the wake
+     * path that would otherwise answer it never comes while the delivery is blocked.
+     */
+    private observeBlockedTaskControl;
     private acknowledgeExecutionControl;
     /**
      * Handler for a resource change (artifact created, task state transition,
@@ -411,6 +419,7 @@ export declare class Agent {
      */
     private canAskForAccess;
     private _processEvent;
+    private _processEventInContext;
     /**
      * The checkout a wake needs, opened before the brain runs. Null when this
      * wake needs none; `'refused'` when the task was failed here by name.
@@ -433,6 +442,7 @@ export declare class Agent {
      * Borrowing that path would make a dev tool able to disturb a live one.
      */
     replayWake(record: WakeRecord): Promise<TickOutput>;
+    private replayWakeInContext;
     /** Arms the lane's liveness timer iff stateName is a parked state declaring timeoutMs. */
     private _armIfTimedParked;
     private _resolveOwnAgentId;

package/dist/Agent.js

@@ -1,3 +1,4 @@
+import { validateWorkExecution, withWorkExecution, currentWorkExecution } from '@ziggs-ai/api-client';
 import { SERVER_EVENTS } from '@ziggs-ai/contracts';
 import { withAgreementContext } from './runtime/agreementContext.js';
 import { agreementLaneId, agreementIdFromLane, isContextAccessRequest } from '@ziggs-ai/api-client';
@@ -521,8 +522,10 @@ export class Agent {
         if (!this.taskService)
             return null;
         let task;
+        // Host control observation is separate from task work. Only execution state
+        // leaves this method; a stopped work context cannot observe its own stop.
         try {
-            task = await this.taskService.getTask(taskId);
+            task = await withWorkExecution(undefined, () => this.taskService.getTask(taskId));
         }
         catch (error) {
             // Unreadable is not a hold. The wake filter still drops a frame whose
@@ -536,6 +539,17 @@ export class Agent {
             return null;
         return { blocked: task.state === 'cancelled' || (task.state === 'active' && task.control?.action === 'pause'), closed: task.state === 'cancelled', control: task.control };
     }
+    /**
+     * Control on an assignment the inbox will not run yet. No wake follows, so a
+     * resume is acknowledged here too once no run of the task is live; the wake
+     * path that would otherwise answer it never comes while the delivery is blocked.
+     */
+    async observeBlockedTaskControl(taskId) {
+        const execution = await this.taskExecutionControl(taskId);
+        const idleResume = execution?.control?.action === 'resume' && !this.activeTaskRuns.get(taskId)?.size;
+        if (execution?.blocked || idleResume)
+            await this.acknowledgeExecutionControl(taskId, execution?.control);
+    }
     async acknowledgeExecutionControl(taskId, control) {
         if (control?.status !== 'requested')
             return;
@@ -626,9 +640,10 @@ export class Agent {
         }
         if (!sessionId)
             return;
-        const laneKey = laneKeyFor(ownAgentId, sessionId);
+        const executionContext = event.executionContext;
+        const laneKey = laneKeyFor(ownAgentId, sessionId, executionContext?.contextId);
         if (!this.sessions.has(laneKey)) {
-            this.sessions.set(laneKey, { sessionId, ownAgentId });
+            this.sessions.set(laneKey, { sessionId, ownAgentId, executionContext });
         }
         const agreementId = resumeAgreementId ||
             (typeof event.agreementId === 'string' && event.agreementId) ||
@@ -656,7 +671,7 @@ export class Agent {
             ['proposal_approved', 'proposal_rejected'].includes(notice?.operation ?? '') &&
             isContextAccessRequest(notice?.agreement?.grantRequest))
             return;
-        const messageId = metadata.messageId;
+        const messageId = (metadata.responsibilityId ?? metadata.messageId);
         if (messageId && this.seenMessages.has(messageId)) {
             runtimeLog.debug('Agent', `skip duplicate messageId=${messageId}`);
             return;
@@ -688,9 +703,10 @@ export class Agent {
             runtimeLog.warn('Agent', `session resolver returned null ownAgentId=${ownAgentId} chatId=${normalized.chatId ?? 'null'}`);
             return;
         }
-        const laneKey = laneKeyFor(ownAgentId, sessionId);
+        const executionContext = metadata.executionContext;
+        const laneKey = laneKeyFor(ownAgentId, sessionId, executionContext?.contextId);
         if (!this.sessions.has(laneKey)) {
-            this.sessions.set(laneKey, { sessionId, ownAgentId });
+            this.sessions.set(laneKey, { sessionId, ownAgentId, executionContext });
         }
         // The inbox loop owns ack (act-before-ack, delivery law); the agent only
         // routes the event onto its lane. No live-path watermark ack — there is no
@@ -745,6 +761,9 @@ export class Agent {
         }), isTelemetryIngestEnabled(this.options.telemetryIngest));
     }
     memoryForWake(session, event) {
+        const execution = currentWorkExecution();
+        if (execution)
+            return partitionMemoryStore(this.memory, `execution:${execution.contextId}`);
         const fromEvent = hireIdsFromEvent(event);
         const wakeAgreementIds = fromEvent.length ? fromEvent : uniqueHireIds([session.actingHireId]);
         const section = memorySectionForWake({
@@ -939,7 +958,9 @@ export class Agent {
         // say so in a sentence, and muting it would be a worse silence.
         let assigned;
         try {
-            assigned = await this.taskService.getActiveTasksForAgent(agentId);
+            // A host check across this agent's own plate, not a read inside the
+            // work: it runs outside the selected execution.
+            assigned = await withWorkExecution(undefined, () => this.taskService.getActiveTasksForAgent(agentId));
         }
         catch (err) {
             runtimeLog.warn(this.options.name || 'agent', `needs check could not read assigned work: ${err?.message ?? err}`);
@@ -1026,9 +1047,14 @@ export class Agent {
         return tools.some((t) => toolName(t) === 'connection_request');
     }
     async _processEvent(event, laneKey) {
+        return withWorkExecution(this.sessions.get(laneKey)?.executionContext, () => this._processEventInContext(event, laneKey));
+    }
+    async _processEventInContext(event, laneKey) {
         const session = this.sessions.get(laneKey);
         if (!session?.sessionId)
             return;
+        if (session.executionContext)
+            await validateWorkExecution(session.executionContext, this.options.operatorKey, resolveBackendUrl());
         // Presentation may call our sender an rpb-* room binding or the person we
         // stand in for. Only an exact (chat, messageId) we successfully sent proves
         // an echo; another message from the same binding still gets a full wake.
@@ -1144,6 +1170,7 @@ export class Agent {
         if (this.options.wakeTap) {
             try {
                 this.options.wakeTap({
+                    executionContext: session.executionContext,
                     agentId: identity.agentId,
                     sessionId: identity.sessionId,
                     laneKey,
@@ -1439,7 +1466,7 @@ export class Agent {
             needs,
             taskId,
             getTask: (id) => this.taskService.getTask(id),
-            listConnections: () => new ConnectionsClient(operatorKey, agentId, undefined, laneId).listForHolder(),
+            listConnections: () => new ConnectionsClient(operatorKey, agentId, undefined).listForHolder(),
             door: { backendUrl: resolveBackendUrl(), operatorKey, agentId, laneId },
             failTask: async (id, reason) => {
                 await this.taskService.updateState(id, 'failed', { summary: reason, status: 'failed' });
@@ -1481,8 +1508,13 @@ export class Agent {
      * Borrowing that path would make a dev tool able to disturb a live one.
      */
     async replayWake(record) {
+        return withWorkExecution(record.executionContext, () => this.replayWakeInContext(record));
+    }
+    async replayWakeInContext(record) {
         if (!record?.sessionId)
             throw new Error('replayWake: record.sessionId is required');
+        if (record.executionContext)
+            await validateWorkExecution(record.executionContext, this.options.operatorKey, resolveBackendUrl());
         const identity = {
             agentId: record.agentId || this.options.agentId,
             sessionId: record.sessionId,
@@ -1593,6 +1625,7 @@ export class Agent {
                 onResourceEvent: (event) => {
                     return this.handleResourceEvent(event);
                 },
+                onTaskControlCheck: (taskId) => this.observeBlockedTaskControl(taskId),
                 // work delivered by the inbox's task channel, not by a chat
                 // row — this is what reaches a task under a chat-less agreement or one
                 // the agent assigned to itself.
@@ -1602,6 +1635,7 @@ export class Agent {
                     }
                     catch (err) {
                         runtimeLog.warn(this.options.name || 'agent', `inbox task ${task.taskId} could not be woken: ${err.message}`);
+                        throw err;
                     }
                 },
                 // exact-match triage in code — miss acks with 0 tokens.
@@ -1631,6 +1665,7 @@ export class Agent {
             firesAt: armed.firesAt,
             reason,
             ...(scope ? { scope } : {}),
+            executionContext: currentWorkExecution(),
         });
         return { ...armed, durable: this.wakeLedger.durable };
     }
@@ -1653,12 +1688,12 @@ export class Agent {
             return;
         }
         for (const wake of pending) {
-            if (wake.laneKey !== laneKeyFor(agentId, wake.sessionId))
+            if (wake.laneKey !== laneKeyFor(agentId, wake.sessionId, wake.executionContext?.contextId))
                 continue;
             if (this.stateTimers.peek(wake.laneKey))
                 continue;
             if (!this.sessions.has(wake.laneKey)) {
-                this.sessions.set(wake.laneKey, { sessionId: wake.sessionId, ownAgentId: agentId });
+                this.sessions.set(wake.laneKey, { sessionId: wake.sessionId, ownAgentId: agentId, executionContext: wake.executionContext });
             }
             try {
                 this.stateTimers.armWakeAt(wake.laneKey, wake.firesAt, wake.reason, wake.scope);
@@ -1704,7 +1739,7 @@ export class Agent {
         const sessionId = laneSessionIdForTask(full);
         const laneKey = laneKeyFor(agentId, sessionId);
         if (!this.sessions.has(laneKey)) {
-            this.sessions.set(laneKey, { sessionId, ownAgentId: agentId });
+            this.sessions.set(laneKey, { sessionId, ownAgentId: agentId, executionContext: currentWorkExecution() });
         }
         await this.eventQueue.enqueue({
             type: 'task_result',

package/dist/brain/claudeSdkTools.d.ts

@@ -1,5 +1,5 @@
 import { type ToolDefinition } from '../tools/defineTool.js';
-import { cancelTaskTool, listTasksTool } from '../platform/tools/tier2/taskTools.js';
+import { cancelTaskTool, listTasksTool, delegateTaskTool } from '../platform/tools/tier2/taskTools.js';
 import type { EffectHandler, DeliveryWriteKeys } from '../types.js';
 import type { MemoryStore } from '../memory/MemoryStore.js';
 export interface ClaudeSdkToolContext extends Record<string, unknown> {
@@ -25,5 +25,5 @@ export interface ClaudeSdkToolContext extends Record<string, unknown> {
 }
 export declare const contextSnapshotTool: ToolDefinition;
 export declare const chatSendTool: ToolDefinition;
-export { listTasksTool, cancelTaskTool };
+export { listTasksTool, cancelTaskTool, delegateTaskTool };
 export declare const CLAUDE_SDK_TOOLS: ToolDefinition[];

package/dist/brain/claudeSdkTools.js

@@ -5,7 +5,7 @@ import { credsFromToolContext } from '../tools/toolCreds.js';
 import { sendChatMessage, presentSendResult } from '@ziggs-ai/api-client';
 import { defineTool } from '../tools/defineTool.js';
 import { listGrantsTool } from '../platform/tools/tier2/grantsTools.js';
-import { cancelTaskTool, listTasksTool } from '../platform/tools/tier2/taskTools.js';
+import { cancelTaskTool, listTasksTool, delegateTaskTool } from '../platform/tools/tier2/taskTools.js';
 import { CHAT_TOOLS } from '../platform/tools/tier2/chatTools.js';
 // default message-history cap. An uncapped snapshot returns the whole
 // chat — in a delegation chat that accumulates notification rows, every wake's
@@ -168,13 +168,14 @@ export const chatSendTool = defineTool('chat_send', {
 // task_list IS here: MCP delegates have ziggs_task_list; the hosted
 // Claude surface previously had no way to enumerate its own open tasks (reads
 // were prompt-injected only). Same GET /tasks capability as the MCP tool.
-export { listTasksTool, cancelTaskTool };
+export { listTasksTool, cancelTaskTool, delegateTaskTool };
 export const CLAUDE_SDK_TOOLS = [
     contextSnapshotTool,
     chatSendTool,
     listGrantsTool,
     listTasksTool,
     cancelTaskTool,
+    delegateTaskTool,
     // store-claim providers must open the buyer chat from the default
     // Claude surface (chat_open was tier-2 / email-agent opt-in only).
     ...CHAT_TOOLS,

package/dist/brain/wakeGate.js

@@ -1,4 +1,4 @@
-import { buildOperatorHeaders, getBackendUrl } from '@ziggs-ai/api-client';
+import { buildOperatorHeaders, getBackendUrl, withoutExecution } from '@ziggs-ai/api-client';
 import { getBatchEvents } from '../context/batch.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
 /** Longer than Jev's own 4s budget on the server, shorter than a turn is worth waiting for. */
@@ -52,7 +52,7 @@ export function backendWakeGate(creds) {
             const res = await fetch(`${getBackendUrl()}/internal/wake-gate`, {
                 method: 'POST',
                 headers: {
-                    ...buildOperatorHeaders(creds.operatorKey, creds.agentId),
+                    ...withoutExecution(buildOperatorHeaders(creds.operatorKey, creds.agentId)),
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify(req),

package/dist/checkout/boxClient.d.ts

@@ -9,6 +9,7 @@ export interface GitDoorTarget {
     operatorKey: string;
     agentId: string;
     laneId?: string;
+    executionContextId?: string;
     connectionId: string;
     grantId: string;
     taskId: string;

package/dist/checkout/boxClient.js

@@ -1,4 +1,3 @@
-import { laneHeader } from '@ziggs-ai/api-client';
 import { runtimeLog } from '../shared/runtimeLog.js';
 /** Headers git sends that the door needs to see; anything else stays behind. */
 const GIT_REQUEST_HEADERS = ['content-type', 'content-encoding', 'accept', 'git-protocol'];
@@ -23,8 +22,8 @@ export function doorHeaders(door, gitHeaders) {
         'x-grant-id': door.grantId,
         'x-ziggs-task-id': door.taskId,
     };
-    for (const [key, value] of Object.entries(laneHeader(door.laneId)))
-        out[key.toLowerCase()] = value;
+    if (door.executionContextId)
+        out['x-ziggs-execution'] = door.executionContextId;
     for (const [k, v] of Object.entries(gitHeaders)) {
         if (GIT_REQUEST_HEADERS.includes(k.toLowerCase()))
             out[k.toLowerCase()] = v;

package/dist/checkout/open.js

@@ -1,3 +1,4 @@
+import { assistantRequestHeaders } from '@ziggs-ai/api-client';
 import { createHash, randomBytes } from 'node:crypto';
 import { CheckoutBoxClient, doorHeaders } from './boxClient.js';
 import { checkoutBranchForTask, checkoutTargetFromTask } from './intake.js';
@@ -69,6 +70,7 @@ export async function openCheckout(deps) {
                 continue;
             const candidate = {
                 ...deps.door,
+                executionContextId: assistantRequestHeaders()['X-Ziggs-Execution'],
                 connectionId: group.connectionId,
                 grantId,
                 taskId,

package/dist/mcp/createMcpAgent.js

@@ -1,4 +1,4 @@
-import { resolveWebAppOrigin, connectionsSettingsAppUrl, laneHeader } from '@ziggs-ai/api-client';
+import { resolveWebAppOrigin, connectionsSettingsAppUrl, assistantRequestHeaders, currentWorkExecution } from '@ziggs-ai/api-client';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
@@ -24,13 +24,19 @@ export class ZiggsGatewayError extends Error {
         this.status = status;
     }
 }
+/** Open gateway sessions kept per selected execution before the oldest closes. */
+const MAX_WORK_SESSIONS = 16;
 /**
  * Wrap fetch so structured gateway denials (401/403 with a `code` body)
  * surface as ZiggsGatewayError instead of a generic transport failure.
  */
 export function wrapGatewayFetch(baseFetch = fetch) {
     return (async (input, init) => {
-        const response = await baseFetch(input, init);
+        const headers = new Headers(init?.headers);
+        headers.delete('X-Ziggs-Execution');
+        for (const [key, value] of Object.entries(assistantRequestHeaders()))
+            headers.set(key, value);
+        const response = await baseFetch(input, { ...init, headers });
         if (response.status === 401 || response.status === 403) {
             const body = (await response
                 .clone()
@@ -71,7 +77,7 @@ export function resolveZiggsGatewayTarget(config, defaults = {}) {
             // its lane, so the same account and the same grant got two different
             // answers depending on which door the agent used. Built by the shared
             // helper, because a copy of this header going missing is invisible.
-            ...laneHeader(defaults.laneId),
+            ...assistantRequestHeaders(),
         },
     };
 }
@@ -97,7 +103,7 @@ export function resolvePerUserGatewayTarget(config, agentId, userId, onBehalfOfA
             // uses this agreement to resolve the delegation root's user.
             ...(onBehalfOfAgreementId ? { 'x-on-behalf-of-agreement': onBehalfOfAgreementId } : {}),
             // The lane, for the same reason as the path-id door above.
-            ...laneHeader(laneId),
+            ...assistantRequestHeaders(),
         },
     };
 }
@@ -343,7 +349,7 @@ export async function createMcpAgent(options) {
             // grants this session may spend, so sessions must not be shared across
             // any of the three. The headers are fixed when the transport is built,
             // so a session reused across lanes would carry the first lane's fence.
-            const cacheKey = `${userId}|${onBehalfOfAgreementId ?? ''}|${laneId ?? ''}`;
+            const cacheKey = `${userId}|${onBehalfOfAgreementId ?? ''}|${assistantRequestHeaders()['X-Ziggs-Execution'] ?? ''}`;
             let p = clients.get(cacheKey);
             if (!p) {
                 p = (async () => {
@@ -387,7 +393,7 @@ export async function createMcpAgent(options) {
             if (!operatorKey)
                 return null;
             try {
-                const body = await new ConnectionsClient(operatorKey, agentId, backendBase, laneId).requestMcpConnection({
+                const body = await new ConnectionsClient(operatorKey, agentId, backendBase).requestMcpConnection({
                     serverUrl: transportConfig.serverUrl,
                     tools: tools.map(t => t.name),
                     onBehalfOfUserId: userId,
@@ -477,7 +483,31 @@ export async function createMcpAgent(options) {
     try {
         await client.connect(transport);
         const rawTools = capTools((await client.listTools()).tools, agentOptions.agentId, maxTools, extraTools.length, allowedTools);
-        const caller = (name, args) => client.callTool({ name, arguments: args });
+        // A brokered gateway session is bound to the work it was opened in, so a
+        // call made inside a selected execution opens (and keeps) a session of its
+        // own; the boot session serves calls made outside any execution.
+        const workClients = new Map();
+        const clientFor = () => {
+            const work = transportConfig.type === 'ziggs' ? currentWorkExecution()?.contextId : undefined;
+            if (!work)
+                return Promise.resolve(client);
+            let pending = workClients.get(work);
+            if (!pending) {
+                if (workClients.size >= MAX_WORK_SESSIONS) {
+                    const [oldest, closing] = workClients.entries().next().value;
+                    workClients.delete(oldest);
+                    void closing.then(c => c.close()).catch(() => { });
+                }
+                const scoped = new Client({ name: 'ziggs-mcp-agent', version: '1.0.0' });
+                pending = scoped
+                    .connect(buildTransport(transportConfig, { agentId: agentOptions.agentId }))
+                    .then(() => scoped);
+                pending.catch(() => workClients.delete(work));
+                workClients.set(work, pending);
+            }
+            return pending;
+        };
+        const caller = async (name, args) => (await clientFor()).callTool({ name, arguments: args });
         const mcpTools = mapMcpTools(caller, rawTools);
         const resolvedWorkflow = workflow ?? buildDefaultWorkflow(agentOptions.description ?? '', rawTools);
         const agent = createAgent({
@@ -487,7 +517,9 @@ export async function createMcpAgent(options) {
         });
         return {
             agent,
-            closeMcp: () => client.close(),
+            closeMcp: async () => {
+                await Promise.all([client, ...workClients.values()].map(c => Promise.resolve(c).then(open => open.close()).catch(() => { })));
+            },
             toolNames: rawTools.map((t) => t.name),
         };
     }

package/dist/platform/WakeLedger.d.ts

@@ -1,3 +1,4 @@
+import type { WorkExecutionContext } from '@ziggs-ai/api-client';
 import { type MemoryStore } from '../memory/MemoryStore.js';
 import type { WorkScope } from '../runtime/wakeEffects.js';
 /** One check-back an agent asked for, as it is kept across a restart. */
@@ -7,6 +8,7 @@ export interface SavedWake {
     firesAt: number;
     reason: string | null;
     scope?: WorkScope;
+    executionContext?: WorkExecutionContext;
 }
 /**
  * Where an agent's own check-backs are kept, so a restart does not lose them.

package/dist/platform/WakeLedger.js

@@ -60,6 +60,7 @@ export class WakeLedger {
                 firesAt: saved.firesAt,
                 reason: saved.reason ?? null,
                 ...(saved.scope ? { scope: saved.scope } : {}),
+                ...(saved.executionContext ? { executionContext: saved.executionContext } : {}),
             });
         }
         return out;

package/dist/platform/ZiggsEffectHandler.js

@@ -28,7 +28,7 @@ async function buildSnapshot(deps, chatId, agentId, opts = {}) {
         // Read as this wake: the session is the lane, the way its tool calls are
         // sent. Without it a room filed in another workspace — a stranger's room
         // with a listed agent — reads as missing and the wake is skipped.
-        const reader = deps.contextReadClient.withLane?.(chatId) ?? deps.contextReadClient;
+        const reader = deps.contextReadClient;
         const snap = await reader.snapshot(chatId, {
             maxMessages: opts.limit,
             ...opts.workScope,

package/dist/platform/agreements/AgreementService.d.ts

@@ -29,7 +29,9 @@ export declare class AgreementService {
      */
     publishOffer(payload: PublishOfferPayload): Promise<Agreement>;
     delegate(payload: DelegateAgreementData): Promise<Agreement>;
-    respond(agreementId: string, action: 'approve' | 'reject'): Promise<Agreement>;
+    respond(agreementId: string, action: 'approve' | 'reject', opts?: {
+        mandateAgreementId?: string;
+    }): Promise<Agreement>;
     /**
      * claim any open broadcast (request, standing offer, hand-off,
      * link invite). Routing (offer vs agreement claim endpoint) is decided in

package/dist/platform/agreements/AgreementService.js

@@ -44,8 +44,8 @@ export class AgreementService {
     delegate(payload) {
         return delegateAgreement(payload, this.creds);
     }
-    respond(agreementId, action) {
-        return respondToAgreement(agreementId, action, this.creds);
+    respond(agreementId, action, opts = {}) {
+        return respondToAgreement(agreementId, action, this.creds, opts);
     }
     /**
      * claim any open broadcast (request, standing offer, hand-off,

package/dist/platform/inboxLoop.d.ts

@@ -32,6 +32,8 @@ export interface InboxLoopDeps {
      * public request burns a full Claude turn per published supplier.
      */
     onRequest?: (request: InboxRequestRef) => Promise<void>;
+    /** Host-only control observation for blocked task assignments; never a model wake. */
+    onTaskControlCheck?: (taskId: string) => Promise<void>;
     label?: string;
 }
 export interface InboxPassResult {
@@ -52,6 +54,13 @@ export interface InboxPassResult {
      * watermark was deliberately held, so the same window arrives again.
      */
     failures: number;
+    /**
+     * Assigned work this host was not allowed to run: a delivery it cannot open
+     * or prepare, a task or decision whose execution was refused. Skipped, not
+     * failed: the server keeps it pending, stops ringing for it, and offers it
+     * again once it can run, so it neither holds the watermark nor slows the loop.
+     */
+    blocked: number;
 }
 /**
  * A capability probe waits on a `probe_*` chat reply, not inbox ack. Act

package/dist/platform/inboxLoop.js

@@ -1,3 +1,4 @@
+import { deliveryHandlingId, withWorkExecution } from '@ziggs-ai/api-client';
 import { ContextReadClient, InboxClient, planInboxAck, planPartialInboxAck, } from '@ziggs-ai/api-client';
 import { runtimeLog } from '../shared/runtimeLog.js';
 import { isRateLimited } from '@ziggs-ai/api-client';
@@ -64,9 +65,9 @@ function proposalIsMine(proposal, ownAgentId) {
 async function deliverMessagesForChat(deps, news, refs, reader, attempt, handledIds) {
     const pending = new Map(refs.map(ref => [ref.resourceId, ref]));
     for (const id of pending.keys()) {
-        if (deps.seen.has(id)) {
+        if (deps.seen.has(deliveryHandlingId(pending.get(id)))) {
+            handledIds.add(deliveryHandlingId(pending.get(id)));
             pending.delete(id);
-            handledIds.add(id);
         }
     }
     if (!pending.size)
@@ -89,6 +90,9 @@ async function deliverMessagesForChat(deps, news, refs, reader, attempt, handled
                 throw err;
             // This read explicitly establishes that these deliveries are inaccessible.
             // The server also excludes out-of-reach rows from its acknowledgment guard.
+            // A context refusal (including changed audience) must be retried, never acknowledged as read.
+            if (refs.some(ref => ref.executionContext))
+                throw err;
             for (const id of pending.keys())
                 handledIds.add(id);
             return delivered;
@@ -104,11 +108,12 @@ async function deliverMessagesForChat(deps, news, refs, reader, attempt, handled
                 // Preserve the message's addressee. Assignment separately authorizes
                 // this carrier to handle it, including a person's stand-in.
                 assigneeId: deps.ownAgentId,
+                ...(ref.responsibilityId ? { responsibilityId: ref.responsibilityId, executionContext: ref.executionContext } : {}),
                 ...(ref.agreementId ? { agreementId: ref.agreementId } : {}),
             }));
             if (handled) {
                 delivered++;
-                handledIds.add(id);
+                handledIds.add(deliveryHandlingId(ref));
             }
             pending.delete(id);
         }
@@ -191,18 +196,52 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     // and the one the window actually bites — releases as soon as it is done.
     // Several, and the oldest is worked last, so the release waits for it: no
     // worse than acking at the end, which is what this replaced.
+    // Blocked work is the server's to retry, not a handover that failed here:
+    // it stays pending without ringing, so holding the mark or backing off for
+    // it would only delay the work that can run.
+    const blocked = envelope.deliveries.filter(d => mine(d) && (d.executionBlocked || d.outOfReach)).length
+        + (envelope.tasksAwaitingMe ?? []).filter(t => t.executionBlocked).length
+        + envelope.proposalsAwaitingMe.filter(p => p.assignedAgentId === deps.ownAgentId && p.executionBlocked).length;
+    if (blocked) {
+        log(label, `${blocked} assignment(s) cannot run yet (no access or execution refused); left pending for the server to offer again`);
+    }
+    if (deps.onTaskControlCheck) {
+        const blockedTasks = new Set([
+            ...envelope.deliveries.filter(d => mine(d) && d.kind === 'task-state' && d.executionBlocked && !d.outOfReach).map(d => d.resourceId),
+            ...(envelope.tasksAwaitingMe ?? []).filter(t => t.executionBlocked).map(t => t.taskId),
+        ]);
+        for (const taskId of blockedTasks) {
+            try {
+                await deps.onTaskControlCheck(taskId);
+            }
+            catch (error) {
+                warn(label, `task control observation failed for ${taskId}: ${error.message}`);
+            }
+        }
+    }
     const handledSoFar = new Set();
-    let lastAckedTo = null;
+    const acknowledged = new Set();
+    // A handled id the server would not settle (it lost access mid-wake) stays
+    // pending there and comes back once it can run; this pass is not redone.
+    const noteRefused = (result) => {
+        const refused = result ? result.refusedDeliveryIds : undefined;
+        if (refused?.length) {
+            warn(label, `ack left ${refused.length} handled assignment(s) pending: ${refused.map(r => `${r.id} (${r.reason})`).join(', ')}`);
+        }
+    };
     const ackWhatIsFinished = async () => {
         const step = planPartialInboxAck(envelope, handledSoFar, {
             ownAgentId: deps.ownAgentId,
             failures,
         });
-        if (!step || step.ackTo === lastAckedTo)
+        if (!step)
+            return;
+        step.handledDeliveryIds = step.handledDeliveryIds.filter(id => !acknowledged.has(id));
+        if (!step.handledDeliveryIds.length)
             return;
         try {
-            await inbox.ack(step.ackTo, { handledResourceIds: step.handledResourceIds });
-            lastAckedTo = step.ackTo;
+            noteRefused(await inbox.ack(step.ackTo, { handledDeliveryIds: step.handledDeliveryIds }));
+            step.handledDeliveryIds.forEach(id => acknowledged.add(id));
             log(label, `acked up to ${step.ackTo} (mid-pass)`);
         }
         catch (err) {
@@ -214,22 +253,25 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     };
     const assignedByChat = new Map();
     for (const d of envelope.deliveries) {
-        if (d.kind !== 'message' || !d.chatId || !mine(d) || d.outOfReach)
+        if (d.kind !== 'message' || !d.chatId || !mine(d) || d.outOfReach || d.executionBlocked)
             continue;
-        const rows = assignedByChat.get(d.chatId) ?? [];
+        const groupId = d.executionContext?.contextId ?? d.chatId;
+        const rows = assignedByChat.get(groupId) ?? [];
         rows.push(d);
-        assignedByChat.set(d.chatId, rows);
+        assignedByChat.set(groupId, rows);
     }
     const chats = [...assignedByChat].map(([chatId, refs]) => ({
         chatId, count: refs.length, latestAt: refs.map(ref => ref.ts).sort().at(-1),
     }));
-    for (const news of chatsInWakeOrder(chats)) {
+    for (const group of chatsInWakeOrder(chats)) {
+        const refs = assignedByChat.get(group.chatId);
+        const news = { ...group, chatId: refs[0].chatId };
         // Read a room's mail as that room's wake would: with the room as the lane.
         // Without it the read is judged in the workspace the key signed in to, and
         // a room another company opened with a listed agent is filed in theirs, so
         // every stranger's message came back 403 and was acked unread.
-        const roomReader = new ContextReadClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl, news.chatId);
-        const n = await deliverMessagesForChat(deps, news, assignedByChat.get(news.chatId), roomReader, attempt, handledSoFar);
+        const roomReader = new ContextReadClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
+        const n = await withWorkExecution(refs[0]?.executionContext, () => deliverMessagesForChat(deps, news, refs, roomReader, attempt, handledSoFar));
         messagesDelivered += n;
         await ackWhatIsFinished();
     }
@@ -243,13 +285,13 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     for (const d of envelope.deliveries) {
         if (d.kind === 'message' || d.kind === 'request')
             continue;
-        if (!mine(d))
+        if (!mine(d) || d.executionBlocked || d.outOfReach)
             continue;
-        const key = `delivery:${d.kind}:${d.resourceId}:${d.ts}`;
+        const key = d.responsibilityId ?? `delivery:${d.kind}:${d.resourceId}:${d.ts}`;
         // Handled on an earlier pass — it still settles this instant, exactly as
         // it does in the end-of-pass list.
         if (deps.seen.has(key)) {
-            handledSoFar.add(d.resourceId);
+            handledSoFar.add(deliveryHandlingId(d));
             continue;
         }
         deps.seen.mark(key);
@@ -257,6 +299,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
             kind: d.kind,
             ts: d.ts,
             resourceId: d.resourceId,
+            ...(d.responsibilityId ? { responsibilityId: d.responsibilityId, executionContext: d.executionContext } : {}),
             ...(d.chatId ? { chatId: d.chatId } : {}),
             ...(d.agreementId ? { agreementId: d.agreementId } : {}),
             ...(d.taskId ? { taskId: d.taskId } : {}),
@@ -268,7 +311,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
         }), () => deps.seen.unmark(key));
         if (handled) {
             resourceEvents++;
-            handledSoFar.add(d.resourceId);
+            handledSoFar.add(deliveryHandlingId(d));
         }
     }
     // An older row here may have been holding the mark back behind the chats.
@@ -278,12 +321,14 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     // taskId+updatedAt — a genuinely touched task wakes again, an untouched one
     // doesn't storm the lane every long-poll.
     for (const task of envelope.tasksAwaitingMe ?? []) {
-        const key = `task:${task.taskId}:${task.updatedAt ?? ''}`;
+        if (task.executionBlocked)
+            continue;
+        const key = `task:${task.taskId}:${task.updatedAt ?? ''}:${task.executionContext?.contextId ?? ''}`;
         if (deps.seen.has(key))
             continue;
         deps.seen.mark(key);
         if (deps.onTask) {
-            const handled = await attempt(`task ${task.taskId}`, () => deps.onTask(task), () => deps.seen.unmark(key));
+            const handled = await attempt(`task ${task.taskId}`, () => withWorkExecution(task.executionContext, () => deps.onTask(task)), () => deps.seen.unmark(key));
             if (handled)
                 tasksDelivered++;
         }
@@ -296,7 +341,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     for (const request of envelope.openRequestsAwaitingMe ?? []) {
         const key = `request:${request.agreementId}:${request.ts}`;
         if (deps.seen.has(key)) {
-            handledSoFar.add(request.agreementId);
+            handledSoFar.add(request.responsibilityId);
             continue;
         }
         deps.seen.mark(key);
@@ -304,25 +349,27 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
             const handled = await attempt(`request ${request.agreementId}`, () => deps.onRequest(request), () => deps.seen.unmark(key));
             if (handled) {
                 requestsTriaged++;
-                handledSoFar.add(request.agreementId);
+                handledSoFar.add(request.responsibilityId);
             }
         }
         else {
             // No handler → still count as handled (ack) so an old host cannot wedge
             // forever on request mail it does not understand.
             requestsTriaged++;
-            handledSoFar.add(request.agreementId);
+            handledSoFar.add(request.responsibilityId);
         }
     }
     // Pending decisions are standing state, not deliveries: they keep appearing
     // until answered, so dedup them the same way tasks are deduped.
     for (const proposal of envelope.proposalsAwaitingMe) {
+        if (proposal.executionBlocked)
+            continue;
         // A proposal may be visible because this agent shares the accountable
         // principal's mailbox. Only the role-designated side actor wakes; ambient
         // sibling proposals remain available as context without creating a lane.
         if (!proposalIsMine(proposal, deps.ownAgentId))
             continue;
-        const key = `proposal:${proposal.agreementId}`;
+        const key = `proposal:${proposal.agreementId}${proposal.executionContext ? ':' + proposal.executionContext.contextId : ''}`;
         if (deps.seen.has(key))
             continue;
         deps.seen.mark(key);
@@ -333,6 +380,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
             agreementId: proposal.agreementId,
             change: 'created',
             reason: 'proposal_pending',
+            ...(proposal.executionContext ? { executionContext: proposal.executionContext } : {}),
         }), () => deps.seen.unmark(key));
         if (handled)
             resourceEvents++;
@@ -344,14 +392,16 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     // Repeated failures never turn unread mail into an acknowledged delivery.
     // One function, shared with the MCP inbox tool — do not restate the list
     // or the allow-gate here.
-    let acked = false;
+    let acked = acknowledged.size > 0;
     const ack = planInboxAck(envelope, {
         ownAgentId: deps.ownAgentId,
         failures,
         forceAck: false,
     });
-    if (ack.allowed && ack.handledResourceIds.every(id => handledSoFar.has(id))) {
-        await inbox.ack(envelope.ackTo, { handledResourceIds: ack.handledResourceIds });
+    if (ack.allowed && ack.handledDeliveryIds.every(id => handledSoFar.has(id))) {
+        const remaining = ack.handledDeliveryIds.filter(id => !acknowledged.has(id));
+        if (remaining.length || !acked)
+            noteRefused(await inbox.ack(envelope.ackTo, { handledDeliveryIds: remaining }));
         acked = true;
         log(label, `acked up to ${envelope.ackTo}`);
     }
@@ -368,6 +418,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
         acked,
         truncated: envelope.deliveriesCapped,
         failures,
+        blocked,
     };
 }
 /**
@@ -380,7 +431,7 @@ const ERROR_BACKOFF_BASE_MS = 1_000;
 const ERROR_BACKOFF_MAX_MS = 30_000;
 /** Count held windows so retries can back off without discarding mail. */
 export function heldPassAfter(prev, pass) {
-    return !pass.acked && (pass.failures > 0 || pass.truncated) ? prev + 1 : 0;
+    return pass.failures > 0 || (!pass.acked && pass.truncated) ? prev + 1 : 0;
 }
 function sleep(ms, signal) {
     return new Promise((resolve) => {

package/dist/platform/laneKey.d.ts

@@ -8,4 +8,4 @@
  * `a:b` while the queue dispatches `a::b` simply never wakes anything, with
  * nothing in the logs to say so.
  */
-export declare function laneKeyFor(agentId: string, sessionId: string): string;
+export declare function laneKeyFor(agentId: string, sessionId: string, executionContextId?: string): string;

package/dist/platform/laneKey.js

@@ -1,3 +1,4 @@
+import { currentWorkExecution } from '@ziggs-ai/api-client';
 /**
  * The lane key for one agent's one conversation.
  *
@@ -8,6 +9,6 @@
  * `a:b` while the queue dispatches `a::b` simply never wakes anything, with
  * nothing in the logs to say so.
  */
-export function laneKeyFor(agentId, sessionId) {
-    return `${agentId}:${sessionId}`;
+export function laneKeyFor(agentId, sessionId, executionContextId) {
+    return `${agentId}:${executionContextId ?? currentWorkExecution()?.contextId ?? sessionId}`;
 }

package/dist/platform/tools/index.d.ts

@@ -24,7 +24,7 @@ export { PAYMENT_TOOLS, paymentBalanceTool } from './tier2/paymentTools.js';
 export { CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, } from './tier2/connectionTools.js';
 export { CONTEXT_TOOLS, contextReadTool, accessRequestTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
-export { TASK_TOOLS, listTasksTool, cancelTaskTool } from './tier2/taskTools.js';
+export { TASK_TOOLS, listTasksTool, cancelTaskTool, delegateTaskTool } from './tier2/taskTools.js';
 export { PLAN_TOOLS, taskReplacePlanTool } from './tier2/planTools.js';
 export { LINK_TOOLS, linkProposeTool, linkListTool, } from './tier2/linkTools.js';
 export { INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, } from './tier2/introductionTools.js';

package/dist/platform/tools/index.js

@@ -28,7 +28,7 @@ export { CONTEXT_TOOLS, contextReadTool, accessRequestTool, contextDelegateTool,
 // one grant lister across every rail (retires context_discover +
 // payment_list_grants). Always-available on the hosted agent — see CLAUDE_SDK_TOOLS.
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
-export { TASK_TOOLS, listTasksTool, cancelTaskTool } from './tier2/taskTools.js';
+export { TASK_TOOLS, listTasksTool, cancelTaskTool, delegateTaskTool } from './tier2/taskTools.js';
 export { PLAN_TOOLS, taskReplacePlanTool } from './tier2/planTools.js';
 // links (agreements with engagementKind 'link') — cross-org reach.
 ///1022: the rail is two tools; propose/claim/revoke ride the

package/dist/platform/tools/tier1/protocolRunner.js

@@ -72,7 +72,9 @@ cachedAgreements) {
         case 'agreement-respond':
             if (!payload.agreementId || !payload.action)
                 return null;
-            return agreementService.respond(payload.agreementId, payload.action);
+            return agreementService.respond(payload.agreementId, payload.action, typeof payload.mandateAgreementId === 'string' && payload.mandateAgreementId
+                ? { mandateAgreementId: payload.mandateAgreementId }
+                : {});
         case 'agreement-claim': {
             // the one claim verb — request, standing offer, or link invite.
             if (!payload.agreementId)
@@ -334,7 +336,7 @@ async function agreementsInChat(services, chatId, cachedAgreements) {
     }
     try {
         // The room is the lane, as for every read made on a wake.
-        const reader = services.contextReadClient.withLane?.(chatId) ?? services.contextReadClient;
+        const reader = services.contextReadClient;
         const snap = await reader.snapshot(chatId, { maxMessages: 1 });
         const ags = snap.agreements;
         return Array.isArray(ags) ? ags : [];

package/dist/platform/tools/tier1/protocolTools.js

@@ -66,7 +66,11 @@ export const agreementProposeTool = defineTool('agreement_propose', {
     agreementDescription: 'string',
 }, handlerFor('agreement_propose'), { description: 'Propose an agreement — direct, broadcast, or link; there are no separate publish tools. Engagement precedence (posted-first): 1) REUSE an active agreement on matching terms, 2) CLAIM the counterparty\'s listing (marketplace_view → agreement_claim; never counter a listing), 3) POST a request broadcast here when nothing listed fits, 4) direct-propose ONLY for bespoke terms, renegotiation, or commissioning a named counterparty with no listing — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Direction is stated, never guessed: providerId = your own id ("I work, you pay") or providerId = proposedTo ("you work, I pay") on direct proposals. Broadcast with proposedTo="everyone" (fully public), "org" (your org only) or "company" (every team in your company) and no providerId posts a REQUEST any agent may claim. A person or the deploy publishes a standing listing; this agent does not. For a bilateral trust link, use link_propose: it takes an email or an agent id, or neither for a share link. engagementKind defaults to service. Agreements are STANDING by default (no expiry, unlimited tasks under one agreement); set expiresAt or maxExecutions only when the engagement should end on its own.', isAgreementCreation: true });
 export const agreementSubcontractTool = defineTool('agreement_subcontract', agreementSubcontractCapability.params, handlerFor('agreement_subcontract'), { description: agreementSubcontractCapability.descriptions.sdk, isAgreementCreation: true });
-export const agreementRespondTool = defineTool('agreement_respond', { agreementId: { type: 'string', required: true }, action: { type: 'string', required: true, enum: ['approve', 'reject'] } }, handlerFor('agreement_respond'), { description: 'Approve or reject a pending DIRECT agreement proposal addressed to you. Open broadcasts (requests, standing offers, link invites) have no personal approval slot — claim those with agreement_claim instead, or ignore them to pass. ONE exception: a hand-off that pins YOU as provider carries your pending approval even as an open broadcast — approving consents to serving whoever claims it (the row stays open for claims); rejecting cancels the hand-off. Ignoring it leaves the hand-off unclaimable, so always respond.' });
+export const agreementRespondTool = defineTool('agreement_respond', {
+    agreementId: { type: 'string', required: true },
+    action: { type: 'string', required: true, enum: ['approve', 'reject'] },
+    mandateAgreementId: { type: 'string', description: 'The hire you act under, when its setting lets you answer without a person.' },
+}, handlerFor('agreement_respond'), { description: 'Approve or reject a pending DIRECT agreement proposal addressed to you. Open broadcasts (requests, standing offers, link invites) have no personal approval slot — claim those with agreement_claim instead, or ignore them to pass. ONE exception: a hand-off that pins YOU as provider carries your pending approval even as an open broadcast — approving consents to serving whoever claims it (the row stays open for claims); rejecting cancels the hand-off. Ignoring it leaves the hand-off unclaimable, so always respond.' });
 export const agreementClaimTool = defineTool('agreement_claim', agreementClaimCapability.params, handlerFor('agreement_claim'), { description: agreementClaimCapability.descriptions.sdk });
 export const taskSetResultTool = defineTool('task_set_result', {
     taskId: { type: 'string', required: true },

package/dist/platform/tools/tier2/mcpConnectionTools.js

@@ -38,7 +38,7 @@ async function resolveTarget(ctx, toolName, connectionId, grantId) {
     // No explicit baseUrl: ConnectionsClient already resolves it the way the fleet
     // configures it (HTTP_URL). Passing BACKEND_URL here was the same mistake as in
     // the transport — undefined in deployment.
-    const groups = await new ConnectionsClient(creds.operatorKey, creds.agentId, undefined, creds.laneId).listForHolder();
+    const groups = await new ConnectionsClient(creds.operatorKey, creds.agentId, undefined).listForHolder();
     const live = groups.filter((g) => (g.grants ?? []).length > 0);
     if (live.length === 0) {
         throw new Error('No live connection grant. Ask the connection owner to issue one for this agent, then retry.');

package/dist/platform/tools/tier2/taskTools.d.ts

@@ -1,4 +1,5 @@
 import type { ToolDefinition } from '../../../tools/defineTool.js';
 export declare const listTasksTool: ToolDefinition;
+export declare const delegateTaskTool: ToolDefinition;
 export declare const cancelTaskTool: ToolDefinition;
 export declare const TASK_TOOLS: ToolDefinition[];

package/dist/platform/tools/tier2/taskTools.js

@@ -1,7 +1,8 @@
-import { cancelTaskCapability, listTasksCapability, TASK_CAPABILITIES } from '@ziggs-ai/api-client';
+import { delegateTaskCapability, cancelTaskCapability, listTasksCapability, TASK_CAPABILITIES } from '@ziggs-ai/api-client';
 import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
 // GET /tasks, defined once in api-client. MCP ziggs_task_list and this
 // hosted-Claude tool used to re-declare the same filters.
 export const listTasksTool = toolFromCapability(listTasksCapability);
+export const delegateTaskTool = toolFromCapability(delegateTaskCapability);
 export const cancelTaskTool = toolFromCapability(cancelTaskCapability);
 export const TASK_TOOLS = toolsFromCapabilities(TASK_CAPABILITIES);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.41.2",
+  "version": "0.42.2",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "homepage": "https://ziggsai.com/docs",
   "bugs": {
@@ -30,8 +30,8 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.284",
     "@anthropic-ai/sdk": "^0.110.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "0.37.27",
-    "@ziggs-ai/contracts": "^0.31.0",
+    "@ziggs-ai/api-client": "0.38.2",
+    "@ziggs-ai/contracts": "^0.33.1",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",