@ziggs-ai/agent-sdk 0.43.5 → 0.43.7

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 0.43.7
+
+- Message wakes retain the backend's authorized causal predecessors by default, so explicitly linked follow-ups can refer to earlier messages without a quoted reply in the interface. Explicit minimal reads still use only the trigger, and history never changes the selected task or agreement.
+
+## 0.43.6
+
+- Completing a delegated task now returns its result to the work that delegated it. A delegated result only reaches the delegator as a returned output artifact, and an agent that closed its task with `task_set_result` returned nothing, so the delegator was never woken and never saw the result. Before completing a delegated task, the SDK records the result as the task's output artifact. After completing it, the SDK returns that artifact. If either step fails, the failure is logged and the completion still stands.
+
 ## 0.43.5
 
 - A task's input bodies (0.43.4) now actually reach a hosted workflow agent. The agent pins every context read in a wake to that wake's work, and that pin also dropped the artifact the input read named, so the read came back without a body. A read may now narrow to one artifact of the same task or agreement; any other read still gets the wake's own scope.

package/dist/brain/claudeSdkTools.js

@@ -21,7 +21,7 @@ export const contextSnapshotTool = defineTool('context_snapshot', {
     taskId: { type: 'string', description: 'Read this explicit task.' },
     messageId: { type: 'string', description: 'Read this exact message without a saved address or work agreement.' },
     artifactId: { type: 'string', description: 'Read this exact artifact context.' },
-    includeHistory: { type: 'boolean', description: 'Include optional work message history. Task/work context does not require it; the exact triggering message is read independently.' },
+    includeHistory: { type: 'boolean', description: 'Message wakes include bounded conversation context by default. Set false to read only the trigger. Set true to include optional message history for a task or agreement without a message trigger.' },
     maxMessages: { type: 'number', description: `Message history cap (default ${DEFAULT_SNAPSHOT_MAX_MESSAGES}). Pass a larger value when you need deeper history.` },
 }, async (args, ctx) => {
     const c = ctx;
@@ -44,7 +44,7 @@ export const contextSnapshotTool = defineTool('context_snapshot', {
         kind: 'read-context',
         sessionId,
         opts: {
-            includeHistory: args.includeHistory === true,
+            ...(typeof args.includeHistory === 'boolean' ? { includeHistory: args.includeHistory } : {}),
             maxMessages: args.maxMessages != null ? Number(args.maxMessages) : DEFAULT_SNAPSHOT_MAX_MESSAGES,
             ...(messageId || artifactId ? {
                 via: messageId ? `message:${messageId}` : `artifact:${artifactId}`,

package/dist/platform/ZiggsEffectHandler.js

@@ -30,7 +30,7 @@ async function buildSnapshot(deps, agentId, opts = {}) {
         // Select the work independently of its triggering message. A message is
         // the snapshot entry only when it is the selected resource itself.
         const snap = await deps.contextReadClient.snapshot({
-            via, maxMessages: opts.limit,
+            via, maxMessages: opts.includeHistory === false && via.startsWith('message:') ? 1 : opts.limit,
             ...(agreementId ? { agreementId } : {}),
             ...(scope?.artifactId ? { artifactId: scope.artifactId } : {}),
         });
@@ -44,10 +44,31 @@ async function buildSnapshot(deps, agentId, opts = {}) {
         const present = (m) => ({ messageId: m.messageId, text: m.content.text, entryType: 'message', timestamp: Date.parse(m.timestamp), sender: { id: m.sender.isSelf ? agentId : m.sender.ref, type: m.sender.kind }, receiver: { id: m.recipients[0]?.ref } });
         const required = trigger ? [present(trigger)] : [];
         const context = { ...snap, messageRecord: trigger, messageMandate: agreementId ? { agreementId, ...(opts.workScope?.taskId ? { taskId: opts.workScope.taskId } : {}) } : trigger?.mandate ?? undefined };
+        if (trigger && opts.includeHistory !== false) {
+            try {
+                // An ordinary follow-up needs the preceding conversation, even when it
+                // does not explicitly quote a message. The server matches the exact
+                // stored audience and mandate and authorizes every history record.
+                // Keep selected work separate: context never selects execution authority.
+                const conversation = via === `message:${trigger.messageId}`
+                    ? snap
+                    : await deps.contextReadClient.snapshot({ via: `message:${trigger.messageId}`, maxMessages: opts.limit ?? 12 });
+                assertRequiredContext(conversation);
+                const history = new Map(conversation.history.map(m => [m.messageId, present(m)]));
+                history.set(trigger.messageId, present(trigger));
+                return { ...context, history: [...history.values()].sort((a, b) => Number(a.timestamp) - Number(b.timestamp)) };
+            }
+            catch (error) {
+                const refusal = error;
+                if (refusal.status === 401 || refusal.code?.startsWith('EXECUTION_'))
+                    throw error;
+                return { ...context, history: required, historyUnavailable: true };
+            }
+        }
         if (trigger || agreementId) {
             if (opts.includeHistory === true) {
                 try {
-                    const page = agreementId ? await messages.list({ agreementId, taskId: opts.workScope?.taskId, limit: Math.min(opts.limit ?? 12, 30) }) : await messages.replies(trigger.messageId, { limit: Math.min(opts.limit ?? 12, 30) });
+                    const page = await messages.list({ agreementId, taskId: opts.workScope?.taskId, limit: Math.min(opts.limit ?? 12, 30) });
                     const history = page.messages.map(present);
                     if (trigger && !page.messages.some(m => m.messageId === trigger.messageId))
                         history.unshift(present(trigger));

package/dist/platform/tasks/TaskService.d.ts

@@ -34,6 +34,15 @@ export declare class TaskService {
         resultRecorded?: boolean;
         terminalState?: string;
     }>;
+    /**
+     * A delegated task's result only reaches the work that delegated it as a
+     * returned output artifact. A workflow agent closes its task with a result
+     * and nothing else, so the delegator never woke and never saw it. Before
+     * completing, record the result as this task's output; after, return it.
+     * Either step failing leaves the completion itself untouched.
+     */
+    private delegatedOutput;
+    private returnDelegatedOutput;
     /**
      * Say who this task is waiting on, with no other progress to post.
      *

package/dist/platform/tasks/TaskService.js

@@ -1,4 +1,4 @@
-import { createTask, getTask, getActiveTasksForAgent, getSubtasks, updateTaskState, updateTaskPlanStep, updateTaskPlanSteps, cancelTask, reportTask, setTaskSatisfaction, countTasks, acknowledgeTaskControl, presentTaskOutcome, } from '@ziggs-ai/api-client';
+import { createTask, getTask, getActiveTasksForAgent, getSubtasks, updateTaskState, updateTaskPlanStep, updateTaskPlanSteps, cancelTask, reportTask, setTaskSatisfaction, countTasks, acknowledgeTaskControl, presentTaskOutcome, returnTaskResult, ArtifactsClient, } from '@ziggs-ai/api-client';
 import { runtimeLog } from '../../shared/runtimeLog.js';
 function safeJsonStringify(value) {
     if (value === null || value === undefined)
@@ -64,8 +64,11 @@ export class TaskService {
                 ...(idempotencyKey ? { idempotencyKey } : {}),
                 ...(sources ? { sources } : {}),
             };
+            const output = state === 'completed' ? await this.delegatedOutput(taskId, result, idempotencyKey) : undefined;
             const updated = await updateTaskState(taskId, state, data, this.creds);
             runtimeLog.info('TaskService', `Task state: ${taskId} → ${state}`);
+            if (output)
+                await this.returnDelegatedOutput(taskId, output);
             // The same four facts the MCP surface reports, from the same
             // presenter: what was stored, who was woken, what metering did, what the
             // agreement is now. Both surfaces say it once, and say it the same way.
@@ -79,6 +82,44 @@ export class TaskService {
             throw error;
         }
     }
+    /**
+     * A delegated task's result only reaches the work that delegated it as a
+     * returned output artifact. A workflow agent closes its task with a result
+     * and nothing else, so the delegator never woke and never saw it. Before
+     * completing, record the result as this task's output; after, return it.
+     * Either step failing leaves the completion itself untouched.
+     */
+    async delegatedOutput(taskId, result, idempotencyKey) {
+        try {
+            const task = await getTask(taskId, this.creds);
+            if (!task?.delegation || task.delegation.returnedArtifactId)
+                return undefined;
+            const summary = result?.summary;
+            const text = typeof summary === 'string' ? summary : safeJsonStringify(result);
+            if (!text || !String(text).trim())
+                return undefined;
+            const recorded = await new ArtifactsClient(this.creds.operatorKey, this.creds.agentId).writeStrict({
+                taskId,
+                text: String(text),
+                name: `Result of task ${taskId}`,
+                ...(idempotencyKey ? { idempotencyKey: `${idempotencyKey}:output` } : {}),
+            });
+            return recorded.artifactId;
+        }
+        catch (error) {
+            runtimeLog.warn('TaskService', `Delegated result for ${taskId} not recorded as an output: ${error.message}`);
+            return undefined;
+        }
+    }
+    async returnDelegatedOutput(taskId, artifactId) {
+        try {
+            const returned = await returnTaskResult(taskId, artifactId, this.creds);
+            runtimeLog.info('TaskService', `Delegated result returned: ${taskId} → ${returned.parentTaskId} (${artifactId}, ${returned.outcome})`);
+        }
+        catch (error) {
+            runtimeLog.warn('TaskService', `Delegated result for ${taskId} not returned: ${error.message}`);
+        }
+    }
     /**
      * Say who this task is waiting on, with no other progress to post.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.43.5",
+  "version": "0.43.7",
   "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.39.2",
-    "@ziggs-ai/contracts": "0.43.0",
+    "@ziggs-ai/api-client": "0.39.3",
+    "@ziggs-ai/contracts": "0.44.0",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",