@ziggs-ai/agent-sdk 0.32.0 → 0.33.0

package/dist/Agent.js

@@ -463,8 +463,10 @@ export class Agent {
             task = await this.taskService.getTask(taskId);
         }
         catch (error) {
+            // Unreadable is not a hold. The wake filter still drops a frame whose
+            // own task cannot be read; a tool that names one gets an error instead.
             if ([403, 404].includes(error.status ?? 0))
-                return { blocked: true };
+                return { blocked: true, unread: true };
             throw error;
         }
         // A coordinator sees its children's task events too; those do not pause it.
@@ -1118,7 +1120,7 @@ export class Agent {
                 release();
             taskRuns.clear();
         };
-        const checkpoint = async (effectTaskId) => {
+        const checkpoint = async (namedTaskId) => {
             if (tickAbort.signal.aborted) {
                 if (tickAbort.signal.reason?.code === 'TASK_CONTROL')
                     heldTask = tickAbort.signal.reason;
@@ -1126,27 +1128,59 @@ export class Agent {
             }
             if (heldTask)
                 throw new Error('Task execution held');
-            const taskId = effectTaskId ?? marks.scope.taskId ?? wakeTaskId;
+            const wakeId = marks.scope.taskId ?? wakeTaskId;
+            const taskId = namedTaskId ?? wakeId;
             if (!taskId)
                 return;
-            registerTaskRun(taskId);
+            // Only this wake's own task shares the tick abort. A tool that names
+            // some other task must not be able to cancel the rest of the wake.
+            const ownsWake = namedTaskId == null || namedTaskId === wakeId;
+            if (ownsWake)
+                registerTaskRun(taskId);
             const execution = await readControl(taskId);
             if (heldTask)
                 throw new Error('Task execution held');
-            if (execution?.blocked) {
-                heldTask = { taskId, control: execution.control };
-                taskRuns.get(taskId).run.control = execution.control;
-                tickAbort.abort(Object.assign(new Error('Task execution held'), { code: 'TASK_CONTROL', taskId, control: execution.control }));
-                throw new Error('Task execution held');
+            if (!execution?.blocked)
+                return;
+            if (!ownsWake || execution.unread) {
+                const error = execution.unread
+                    ? `Task ${taskId} cannot be read. This call did not run.`
+                    : execution.closed
+                        ? `Task ${taskId} is cancelled. This call did not run.`
+                        : `Task ${taskId} is paused. This call did not run.`;
+                return { error };
             }
+            heldTask = { taskId, control: execution.control };
+            taskRuns.get(taskId).run.control = execution.control;
+            tickAbort.abort(Object.assign(new Error('Task execution held'), { code: 'TASK_CONTROL', taskId, control: execution.control }));
+            throw new Error('Task execution held');
+        };
+        const taskIdNamedBy = (effect) => {
+            if (effect.kind !== 'tool-call' || !effect.args || typeof effect.args !== 'object' || Array.isArray(effect.args))
+                return undefined;
+            const args = effect.args;
+            if (typeof args.taskId === 'string')
+                return args.taskId;
+            const nested = args.args;
+            if ((effect.name === 'tool_read' || effect.name === 'tool_write')
+                && nested && typeof nested === 'object' && !Array.isArray(nested)) {
+                const inner = nested.taskId;
+                if (typeof inner === 'string')
+                    return inner;
+            }
+            return undefined;
         };
         const eff = async (effect) => {
             // Record-only telemetry can finish after interruption. Every action and
             // model call checks the current task before starting another operation.
-            if (effect.kind !== 'record-event') {
-                const args = effect.args;
-                const taskId = effect.kind === 'tool-call' && typeof args?.taskId === 'string' ? args.taskId : undefined;
-                await checkpoint(taskId);
+            if (effect.kind === 'tool-call') {
+                const refusal = await checkpoint(taskIdNamedBy(effect));
+                // The handler is generic over every effect. This branch is only a tool call.
+                if (refusal)
+                    return { ok: false, error: refusal.error };
+            }
+            else if (effect.kind !== 'record-event') {
+                await checkpoint();
             }
             const agreementId = marks.scope.agreementId;
             const sameRoom = 'sessionId' in effect && effect.sessionId === session.sessionId;

package/dist/mcp/createMcpAgent.js

@@ -395,14 +395,17 @@ export async function createMcpAgent(options) {
             : 'the external service';
         // Open a connection request for this user; returns its id so the caller can
         // deep-link the user straight to it on the Connections page.
-        const triggerConnectionRequest = async (userId) => {
+        // The server holds the invoking user to the people this wake may ask, so
+        // the request carries the same lane as the call that missed: in the hire's
+        // room that user is its customer.
+        const triggerConnectionRequest = async (userId, laneId) => {
             if (!transportConfig.serverUrl)
                 return null;
             const operatorKey = transportConfig.operatorKey || process.env.ZIGGS_OPERATOR_KEY;
             if (!operatorKey)
                 return null;
             try {
-                const body = await new ConnectionsClient(operatorKey, agentId, backendBase).requestMcpConnection({
+                const body = await new ConnectionsClient(operatorKey, agentId, backendBase, laneId).requestMcpConnection({
                     serverUrl: transportConfig.serverUrl,
                     tools: tools.map(t => t.name),
                     onBehalfOfUserId: userId,
@@ -460,7 +463,7 @@ export async function createMcpAgent(options) {
             if (lastErr instanceof ZiggsGatewayError &&
                 lastErr.code === 'NO_USER_CONNECTION' &&
                 transportConfig.serverUrl) {
-                const requestId = await triggerConnectionRequest(userId).catch(() => null);
+                const requestId = await triggerConnectionRequest(userId, laneId).catch(() => null);
                 const link = connectionsSettingsAppUrl(appUrl, requestId);
                 return {
                     content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.284",
     "@anthropic-ai/sdk": "^0.110.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "0.31.0",
+    "@ziggs-ai/api-client": "0.32.0",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",