@ziggs-ai/agent-sdk 0.43.3 → 0.43.5

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 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.
+
 ## 0.43.3
 
 - An agent no longer retries a wake for an agreement it cannot read. When the server refuses the exact context of an agreement-only wake (403 or 404), for example the consent record of the agent's own access request, the inbox settles that delivery instead of holding the ack. Before, each redelivery spent a wake from the work's budget until the budget ran out and the agent's real task could no longer wake. Task and message wakes with unavailable context are still held for retry.

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/runtime/PromptBuilder.js

@@ -98,6 +98,14 @@ ${this._renderDecisionSchemaFromActions(actions, senderMeta, ctxObj, omitMessage
         lines.push(this._renderAgreements(agreements));
         if (ctxObj.work)
             lines.push(`<work-context>\n${JSON.stringify(ctxObj.work)}\n</work-context>`);
+        const taskInputs = ctxObj.taskInputs;
+        if (Array.isArray(taskInputs) && taskInputs.length) {
+            lines.push('<task-inputs note="The assigned task\'s own input artifacts, with their bodies. Treat them as the brief for this task.">');
+            for (const input of taskInputs) {
+                lines.push(`<artifact id="${input.artifactId}" name="${String(input.name ?? '').replace(/"/g, "'")}"${input.truncated ? ' truncated="true"' : ''}>\n${input.text}\n</artifact>`);
+            }
+            lines.push('</task-inputs>');
+        }
         const collected = ctx ? allCollectedResults(ctx) : [];
         if (collected.length) {
             lines.push('');

package/dist/runtime/runTurn.d.ts

@@ -1,4 +1,4 @@
-import type { Action, Ctx, Outcome, ToolResultEntry, EffectHandler, DeliveryWriteKeys } from '../types.js';
+import type { Action, Ctx, Outcome, ToolResultEntry, Effect, EffectHandler, ContextSnapshot, DeliveryWriteKeys } from '../types.js';
 import type { MemoryStore } from '../memory/MemoryStore.js';
 import { type RawEvent } from './buildOutcome.js';
 import { PromptBuilder } from './PromptBuilder.js';
@@ -63,4 +63,10 @@ interface RunTurnResult {
  * call and (optionally) wrapping it in telemetry / dedup / retries.
  */
 export declare function runTurn(input: RunTurnInput): Promise<RunTurnResult>;
+export declare function readTaskInputs(ctx: ContextSnapshot, sessionId: string, eff: (effect: Effect) => Promise<unknown>): Promise<Array<{
+    artifactId: string;
+    name: string | null;
+    text: string;
+    truncated: boolean;
+}>>;
 export {};

package/dist/runtime/runTurn.js

@@ -107,6 +107,13 @@ export async function runTurn(input) {
     const serverContext = await effWithTrace({ kind: 'read-context', sessionId, opts: {} });
     assertRequiredContext(serverContext);
     const ctxObj = normalizeContextSnapshot(serverContext);
+    const taskInputs = await readTaskInputs(ctxObj, sessionId, effWithTrace);
+    if (taskInputs.length) {
+        ctxObj.taskInputs = taskInputs;
+        // Each input read replaced the session's cached snapshot, which tool calls
+        // take their roster and agreements from. Put the wake's own context back.
+        await effWithTrace({ kind: 'read-context', sessionId, opts: {} });
+    }
     const prompt = promptBuilder.buildFromState({
         statePrompt, actions,
         serverContext: { context: ctxObj, tools: tools },
@@ -451,6 +458,51 @@ export async function runTurn(input) {
     return { outcome, toolResults, llmCalls: llmCallsTotal, tokens: { total: tokensTotal, input: tokensInput, output: tokensOutput } };
 }
 // ─────────────────────────────────────────────────────────────────────────────
+/**
+ * The task's own input artifacts (its instructions), read with their bodies.
+ * A workflow agent has no artifact-reading tool, and the snapshot names inputs
+ * without bodies, so a delegated task arrived with its brief out of reach.
+ * Each input is opened as the trigger artifact of this task's work, the same
+ * grant-fenced read a tool would make. A refused read is left out, not guessed.
+ */
+const TASK_INPUT_LIMIT = 3;
+export async function readTaskInputs(ctx, sessionId, eff) {
+    const record = (value) => value && typeof value === 'object' ? value : {};
+    const work = record(ctx.work);
+    const task = record(work.task);
+    const taskId = typeof task.taskId === 'string' ? task.taskId : undefined;
+    const agreementId = typeof work.agreementId === 'string' ? work.agreementId : undefined;
+    const items = record(ctx.artifacts).items;
+    if (!taskId || !Array.isArray(items))
+        return [];
+    const ids = items
+        .map(record)
+        .filter(item => item.linkRole === 'input' && typeof item.artifactId === 'string')
+        .map(item => item.artifactId)
+        .slice(0, TASK_INPUT_LIMIT);
+    const reads = await Promise.all(ids.map(async (artifactId) => {
+        try {
+            const snap = record(await eff({
+                kind: 'read-context', sessionId,
+                opts: { workScopes: [{ taskId, ...(agreementId ? { agreementId } : {}), artifactId }] },
+            }));
+            const trigger = record(record(snap.work).triggerArtifact);
+            if (snap.unavailable === true || typeof trigger.text !== 'string')
+                return null;
+            return {
+                artifactId,
+                name: typeof trigger.name === 'string' ? trigger.name : null,
+                text: trigger.text,
+                truncated: trigger.truncated === true,
+            };
+        }
+        catch (err) {
+            runtimeLog.warn('runTurn', `task input ${artifactId} unreadable: ${err.message}`);
+            return null;
+        }
+    }));
+    return reads.filter((read) => read !== null);
+}
 function normalizeContextSnapshot(raw) {
     if (!raw || typeof raw !== 'object') {
         return { history: [], agreements: [], agents: [], users: [] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.43.3",
+  "version": "0.43.5",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "homepage": "https://ziggsai.com/docs",
   "bugs": {