@ziggs-ai/agent-sdk 0.43.4 → 0.43.6

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 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.
+
 ## 0.43.4
 
 - A workflow agent working an assigned task now sees the bodies of the task's input artifacts. The work snapshot names a task's inputs without their text, and a workflow agent has no artifact-reading tool, so a delegated task arrived with its instructions out of reach and the agent failed it. Each input (up to three) is read through the same grant-checked context read and shown in the prompt as `<task-inputs>`. An input the agent may not read is left out.

package/dist/Agent.d.ts

@@ -522,3 +522,11 @@ export declare class Agent {
 export declare function createAgent(options?: AgentOptions | AgentConfig): Agent;
 export declare function createAgentPool(configs: AgentOptions[] | AgentConfig[]): Promise<unknown>;
 export default Agent;
+type ReadScope = NonNullable<import('./types.js').ReadContextOpts['workScopes']>[number];
+/**
+ * A read inside a wake stays on that wake's work. A caller may only narrow it
+ * to one artifact of the same task or agreement, which is how a task's input
+ * is opened with its body. Anything else reads the wake's own scopes. The
+ * server still checks every read.
+ */
+export declare function readScopesForWake(asked: ReadScope[] | undefined, wake: ReadScope[]): ReadScope[];

package/dist/Agent.js

@@ -1331,7 +1331,7 @@ export class Agent {
             const agreementId = marks.scope.agreementId;
             const sameRoom = 'sessionId' in effect && effect.sessionId === session.sessionId;
             const scopedEffect = sameRoom && effect.kind === 'read-context'
-                ? { ...effect, opts: { ...effect.opts, workScopes: contextScopesFromWake(frame, session.sessionId) } }
+                ? { ...effect, opts: { ...effect.opts, workScopes: readScopesForWake(effect.opts?.workScopes, contextScopesFromWake(frame, session.sessionId)) } }
                 : agreementId && (effect.kind === 'tool-call' || effect.kind === 'record-event')
                     ? { ...effect, serviceAgreementId: effect.serviceAgreementId ?? agreementId }
                     : effect;
@@ -1894,3 +1894,21 @@ export async function createAgentPool(configs) {
     }
 }
 export default Agent;
+/**
+ * A read inside a wake stays on that wake's work. A caller may only narrow it
+ * to one artifact of the same task or agreement, which is how a task's input
+ * is opened with its body. Anything else reads the wake's own scopes. The
+ * server still checks every read.
+ */
+export function readScopesForWake(asked, wake) {
+    if (!asked?.length)
+        return wake;
+    const narrowed = asked.map(scope => {
+        if (!scope.artifactId || scope.messageId)
+            return undefined;
+        const base = wake.find(w => (w.taskId ?? undefined) === (scope.taskId ?? undefined)
+            && (scope.agreementId ?? w.agreementId) === w.agreementId);
+        return base ? { ...base, artifactId: scope.artifactId } : undefined;
+    });
+    return narrowed.every(Boolean) ? narrowed : wake;
+}

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.4",
+  "version": "0.43.6",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "homepage": "https://ziggsai.com/docs",
   "bugs": {