@agent-native/core 0.84.38 → 0.84.40

package/corpus/README.md

@@ -27,5 +27,5 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- core files: 2043
-- template files: 4995
+- core files: 2044
+- template files: 4998

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.84.40
+
+### Patch Changes
+
+- 96feefd: Checkpoint agent runs that stall while preparing an action input without streaming bytes.
+
+## 0.84.39
+
+### Patch Changes
+
+- ca6912b: Fix hosted Google Analytics / Tag Manager injection by baking the measurement id into Nitro server bundles and merging the required GA/GTM script, connect, and image hosts into existing stricter document CSPs.
+
 ## 0.84.38
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.84.38",
+  "version": "0.84.40",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/agent/action-continuation-guidance.ts

@@ -0,0 +1,38 @@
+// Concrete "ship a compact first version, then refine incrementally" guidance
+// keyed by the large-payload action the model was cut off while preparing.
+// A run cut off before the tool starts tends to reassemble the same oversized
+// payload on every continuation; pointing the model at the incremental path is
+// what breaks that loop.
+export function incrementalActionGuidance(tool: string): string | undefined {
+  switch (tool) {
+    case "create-extension":
+    case "update-extension":
+      return "create a compact working v1 with `create-extension`, then use focused `update-extension` edits for refinements";
+    case "generate-design":
+    case "update-design":
+      return 'if an existing design file or snapshot is already in history, especially after a Design variant pick, stop retrying `generate-design`: call `get-design-snapshot` for the selected file, then call `edit-design` once on that same `fileId` (`mode: "replace-file"` for a compact full-file replacement, or search/replace for smaller edits). Use `generate-design` only for a brand-new compact first file when no target file exists yet';
+    case "edit-design":
+      return "retry with a smaller `edit-design` payload: prefer a handful of exact search/replace edits against the already-snapshotted file, and avoid `replacementContent` for a huge full-file rewrite. If a selected variant needs expansion, upgrade the highest-value visible sections first, save once, and summarize any remaining refinements";
+    case "present-design-variants":
+      return 'call `present-design-variants` with concise labels, descriptions, accent colors, and feature bullets; omit large `content` HTML when needed so the action can render compact representative screens. After the user picks a direction, delete unchosen screens, snapshot the selected `fileId`, and refine that same file with `edit-design` (`mode: "replace-file"` for placeholder expansion). Do not call `generate-design` after the variant pick';
+    case "create-visual-plan":
+    case "create-ui-plan":
+    case "create-plan-design":
+    case "create-prototype-plan":
+      return "create the plan with its core sections or first screen, then expand it with `update-visual-plan`/`patch-visual-plan-source` follow-up edits";
+    case "update-visual-plan":
+    case "patch-visual-plan-source":
+      return "apply smaller, targeted `patch-visual-plan-source` edits rather than rewriting the whole plan in one call";
+    case "update-dashboard":
+      return "save a small dashboard first, then add panels one at a time with `update-dashboard` incremental `ops` edits instead of authoring the whole config in one call";
+    default:
+      return undefined;
+  }
+}
+
+export function actionPreparationContinuationNote(tool: string): string {
+  const guidance = incrementalActionGuidance(tool);
+  return guidance
+    ? `\n\nThe previous run was cut off while preparing the \`${tool}\` action input before the action could finish. Avoid spending another whole run assembling one large tool payload - ${guidance}.`
+    : `\n\nThe previous run was cut off while preparing the \`${tool}\` action input before the action could finish. Avoid re-assembling one large tool payload: produce a compact first result you can finish in a single run, then refine it with smaller follow-up edits.`;
+}

package/corpus/core/src/agent/production-agent.ts

@@ -44,6 +44,7 @@ import {
   normalizeReasoningEffortForModel,
   type ReasoningEffort,
 } from "../shared/reasoning-effort.js";
+import { actionPreparationContinuationNote } from "./action-continuation-guidance.js";
 import { applyContextDirectives } from "./context-xray/apply-directives.js";
 import { loadContextDirectives } from "./context-xray/directives-store.js";
 import {
@@ -984,6 +985,7 @@ function maxRetriesForError(err: unknown): number {
   return MAX_RETRIES;
 }
 const TOOL_INPUT_ACTIVITY_INTERVAL_MS = 1500;
+const ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS = 90_000;
 const MAX_TEXT_ATTACHMENT_CHARS = 60_000;
 const MAX_SELECTION_CONTEXT_CHARS = 8_000;
 const MAX_RESOURCE_INVENTORY_ITEMS = 40;
@@ -1693,11 +1695,13 @@ export type AgentLoopContinuationReason =
   | "max_tokens"
   | "stream_ended"
   | "gateway_timeout"
-  | "network_interrupted";
+  | "network_interrupted"
+  | "no_progress";
 
 export function appendAgentLoopContinuation(
   messages: EngineMessage[],
   reason: AgentLoopContinuationReason,
+  options: { actionPreparationTool?: string } = {},
 ) {
   const note =
     reason === "loop_limit"
@@ -1710,18 +1714,37 @@ export function appendAgentLoopContinuation(
             ? "The previous LLM call hit an upstream gateway timeout before the response finished streaming."
             : reason === "network_interrupted"
               ? "The previous LLM call was cut off by a transport-level interruption (socket dropped, connection reset, or stream closed unexpectedly)."
-              : "The previous run reached an internal execution budget.";
+              : reason === "no_progress"
+                ? "The previous run stopped producing progress events while the connection stayed open."
+                : "The previous run reached an internal execution budget.";
+  const actionInputNote = options.actionPreparationTool
+    ? actionPreparationContinuationNote(options.actionPreparationTool)
+    : "";
   messages.push({
     role: "user",
     content: [
       {
         type: "text",
-        text: `${AGENT_INTERNAL_CONTINUE_PROMPT}\n\nInternal note: ${note}`,
+        text: `${AGENT_INTERNAL_CONTINUE_PROMPT}\n\nInternal note: ${note}${actionInputNote}`,
       },
     ],
   });
 }
 
+function isAgentLoopContinuationReason(
+  reason: unknown,
+): reason is AgentLoopContinuationReason {
+  return (
+    reason === "run_timeout" ||
+    reason === "loop_limit" ||
+    reason === "max_tokens" ||
+    reason === "stream_ended" ||
+    reason === "gateway_timeout" ||
+    reason === "network_interrupted" ||
+    reason === "no_progress"
+  );
+}
+
 /**
  * True when an error thrown by `runAgentLoop` is a recoverable transport- or
  * gateway-level interruption that the agent can resume from rather than a
@@ -2792,6 +2815,15 @@ export async function runAgentLoop(opts: {
         const toolInputNames = new Map<string, string>();
         const toolInputBytes = new Map<string, number>();
         let lastToolInputActivityAt = 0;
+        type ActiveToolInputPreparation = {
+          id: string;
+          toolName?: string;
+          startedAt: number;
+          lastProgressAt: number;
+          bytes: number;
+        };
+        const activeToolInputs = new Map<string, ActiveToolInputPreparation>();
+        let endedForActionPreparationNoProgress = false;
         const sendToolInputActivity = (
           toolName: string | undefined,
           toolInputId?: string,
@@ -2814,8 +2846,65 @@ export async function runAgentLoop(opts: {
             ...(typeof progressBytes === "number" ? { progressBytes } : {}),
           });
         };
+        const resetActiveToolInput = (
+          toolName: string | undefined,
+          toolInputId?: string,
+        ) => {
+          if (toolInputId) {
+            activeToolInputs.delete(toolInputId);
+            return;
+          }
+          if (toolName) {
+            for (const [id, active] of activeToolInputs) {
+              if (active.toolName === toolName) {
+                activeToolInputs.delete(id);
+              }
+            }
+          }
+        };
+        const hasActionPreparationStalled = () => {
+          if (activeToolInputs.size === 0) return false;
+          const now = Date.now();
+          for (const active of activeToolInputs.values()) {
+            if (
+              now - active.lastProgressAt >=
+              ACTION_PREPARATION_NO_PROGRESS_TIMEOUT_MS
+            ) {
+              return true;
+            }
+          }
+          return false;
+        };
+        const trackActiveToolInput = (
+          key: string,
+          toolName: string | undefined,
+          bytes: number,
+        ) => {
+          const now = Date.now();
+          const previous = activeToolInputs.get(key);
+          activeToolInputs.set(key, {
+            id: key,
+            ...((toolName ?? previous?.toolName)
+              ? { toolName: toolName ?? previous?.toolName }
+              : {}),
+            startedAt: previous?.startedAt ?? now,
+            lastProgressAt: now,
+            bytes,
+          });
+        };
+        const clearActiveToolInputs = () => {
+          activeToolInputs.clear();
+        };
 
         for await (const event of eventStream) {
+          if (hasActionPreparationStalled()) {
+            send({
+              type: "auto_continue",
+              reason: "no_progress",
+            });
+            endedForActionPreparationNoProgress = true;
+            break;
+          }
           // In-loop processor seam (stream hook). Each chunk is offered to every
           // processor's `processOutputStream` before the loop handles it. A
           // processor `abort()` throws a TripWire; catch it locally so it is not
@@ -2845,6 +2934,7 @@ export async function runAgentLoop(opts: {
             if (key && event.name) {
               toolInputNames.set(key, event.name);
               toolInputBytes.set(key, 0);
+              trackActiveToolInput(key, event.name, 0);
             }
             sendToolInputActivity(event.name, key, undefined, true);
           } else if (event.type === "tool-input-delta") {
@@ -2859,19 +2949,25 @@ export async function runAgentLoop(opts: {
                 previous +
                 new TextEncoder().encode(event.text ?? "").byteLength;
               toolInputBytes.set(key, progressBytes);
+              if (progressBytes > previous) {
+                trackActiveToolInput(key, toolName, progressBytes);
+              }
             }
             sendToolInputActivity(toolName, key, progressBytes);
           } else if (event.type === "gateway-heartbeat") {
             send({ type: "stream_keepalive" });
           } else if (event.type === "tool-call") {
             // The authoritative tool-call blocks arrive in assistant-content.
+            resetActiveToolInput(event.name, event.id);
           } else if (event.type === "tool-call-error") {
+            resetActiveToolInput(event.name, event.id);
             toolCallErrors.set(event.id, {
               name: event.name,
               input: event.input,
               error: event.error,
             });
           } else if (event.type === "assistant-content") {
+            clearActiveToolInputs();
             assistantContent = event.parts;
           } else if (event.type === "usage") {
             usage.inputTokens += event.inputTokens;
@@ -2889,6 +2985,18 @@ export async function runAgentLoop(opts: {
               });
             }
           }
+          if (hasActionPreparationStalled()) {
+            send({
+              type: "auto_continue",
+              reason: "no_progress",
+            });
+            endedForActionPreparationNoProgress = true;
+            break;
+          }
+        }
+
+        if (endedForActionPreparationNoProgress) {
+          return usage;
         }
 
         break;
@@ -4018,6 +4126,83 @@ function endsAtInternalContinuationBoundary(run: ActiveRun): boolean {
   return last.type === "error" && isRecoverableContinuationError(last);
 }
 
+function isPreparingActionActivityEvent(
+  event: AgentChatEvent,
+): event is Extract<AgentChatEvent, { type: "activity" }> {
+  if (event.type !== "activity") return false;
+  const label = event.label.trim().toLowerCase();
+  return label.startsWith("preparing ") && label.includes(" action");
+}
+
+export function lastUnfinishedPreparingActionToolFromEvents(
+  events: readonly AgentChatEvent[],
+): string | undefined {
+  let active: {
+    id?: string;
+    tool: string;
+  } | null = null;
+  for (const event of events) {
+    if (isPreparingActionActivityEvent(event)) {
+      const tool = event.tool?.trim();
+      if (tool) {
+        active = {
+          tool,
+          ...(event.id?.trim() ? { id: event.id.trim() } : {}),
+        };
+      }
+      continue;
+    }
+    if (event.type === "tool_start" || event.type === "tool_done") {
+      const tool = event.tool?.trim();
+      const id = event.id?.trim();
+      if (
+        active &&
+        ((id && active.id === id) || (!id && tool && active.tool === tool))
+      ) {
+        active = null;
+      }
+      continue;
+    }
+    if (event.type === "error" && isRecoverableContinuationError(event)) {
+      continue;
+    }
+    if (
+      event.type === "clear" ||
+      event.type === "done" ||
+      event.type === "error" ||
+      event.type === "missing_api_key"
+    ) {
+      active = null;
+    }
+  }
+  return active?.tool;
+}
+
+function lastUnfinishedPreparingActionTool(run: ActiveRun): string | undefined {
+  return lastUnfinishedPreparingActionToolFromEvents(
+    run.events.map(({ event }) => event),
+  );
+}
+
+export function backgroundContinuationReasonForRun(
+  run: ActiveRun,
+): AgentLoopContinuationReason {
+  const last = run.events.at(-1)?.event;
+  if (last?.type === "loop_limit") return "loop_limit";
+  if (
+    last?.type === "auto_continue" &&
+    isAgentLoopContinuationReason(last.reason)
+  ) {
+    return last.reason;
+  }
+  if (last?.type === "error" && isRecoverableContinuationError(last)) {
+    return continuationReasonForResumableError(
+      new EngineError(last.error, { errorCode: last.errorCode }),
+    );
+  }
+  return "run_timeout";
+}
+
 /**
  * Hard cap on server-driven background→background continuation chunks for a
  * single logical turn. A `backgroundFunction` run gets a ~13-min soft timeout,
@@ -4981,7 +5166,19 @@ export function createProductionAgentHandler(
           ?.threadData;
         const resumed = threadDataToEngineMessages(priorThreadData);
         if (resumed.length > 0) {
-          appendAgentLoopContinuation(resumed, "run_timeout");
+          const actionPreparationTool =
+            typeof backgroundRunMarker?.actionPreparationTool === "string" &&
+            backgroundRunMarker.actionPreparationTool.trim()
+              ? backgroundRunMarker.actionPreparationTool.trim()
+              : undefined;
+          const continuationReason = isAgentLoopContinuationReason(
+            backgroundRunMarker?.continuationReason,
+          )
+            ? backgroundRunMarker.continuationReason
+            : "run_timeout";
+          appendAgentLoopContinuation(resumed, continuationReason, {
+            ...(actionPreparationTool ? { actionPreparationTool } : {}),
+          });
           messages.length = 0;
           messages.push(...resumed);
         }
@@ -5334,6 +5531,10 @@ export function createProductionAgentHandler(
                 // its seq log starts clean; same turnId folds the assistant
                 // message across chunks.
                 const nextRunId = generateRunId();
+                const actionPreparationTool =
+                  lastUnfinishedPreparingActionTool(run);
+                const continuationReason =
+                  backgroundContinuationReasonForRun(run);
                 const continuationDispatchPath =
                   resolveAgentChatProcessRunDispatchPath();
                 const continuationExpectsNetlifyBackgroundFunction =
@@ -5358,6 +5559,10 @@ export function createProductionAgentHandler(
                         runId: nextRunId,
                         turnId: effectiveTurnId,
                         continuationCount: backgroundContinuationCount + 1,
+                        continuationReason,
+                        ...(actionPreparationTool
+                          ? { actionPreparationTool }
+                          : {}),
                         backgroundFunctionRuntimeExpected:
                           continuationExpectsNetlifyBackgroundFunction,
                       },

package/corpus/core/src/agent/run-loop-with-resume.ts

@@ -27,6 +27,8 @@ import {
   appendAgentLoopContinuation,
   isResumableEngineError,
   continuationReasonForResumableError,
+  lastUnfinishedPreparingActionToolFromEvents,
+  type AgentLoopContinuationReason,
 } from "./production-agent.js";
 import { resolveRunSoftTimeoutMs } from "./run-manager.js";
 import type { ResolveRunSoftTimeoutOptions } from "./run-manager.js";
@@ -35,6 +37,35 @@ import {
   classifyToolCallJournal,
   buildResumeJournalNote,
 } from "./tool-call-journal.js";
+import type { AgentChatEvent } from "./types.js";
+
+async function readCurrentTurnEventsForResume(
+  threadId: string | undefined,
+  localEvents: readonly AgentChatEvent[] = [],
+): Promise<AgentChatEvent[]> {
+  let persistedEvents: AgentChatEvent[] = [];
+  try {
+    persistedEvents = threadId
+      ? await getCurrentTurnEventsForThread(threadId)
+      : [];
+  } catch {
+    persistedEvents = [];
+  }
+  if (localEvents.length === 0) return persistedEvents;
+  const seen = new Set(persistedEvents.map((event) => JSON.stringify(event)));
+  return [
+    ...persistedEvents,
+    ...localEvents.filter((event) => !seen.has(JSON.stringify(event))),
+  ];
+}
+
+function actionPreparationContinuationOptions(
+  events: readonly AgentChatEvent[],
+): { actionPreparationTool?: string } {
+  const actionPreparationTool =
+    lastUnfinishedPreparingActionToolFromEvents(events);
+  return actionPreparationTool ? { actionPreparationTool } : {};
+}
 
 /**
  * Derive the per-turn tool-call journal from the durable run-event ledger and,
@@ -57,13 +88,11 @@ import {
  * complete write tool (returning the journaled result instead). See
  * `tool-call-journal.ts` (`findCompletedJournalEntry`) for the keying used.
  */
-async function appendToolCallJournalNote(
+function appendToolCallJournalNote(
   messages: EngineMessage[],
-  threadId: string | undefined,
-): Promise<void> {
-  if (!threadId) return;
+  events: readonly AgentChatEvent[],
+): void {
   try {
-    const events = await getCurrentTurnEventsForThread(threadId);
     if (events.length === 0) return;
     const journal = classifyToolCallJournal(events);
     const note = buildResumeJournalNote(journal);
@@ -79,12 +108,27 @@ async function appendToolCallJournalNote(
   }
 }
 
+async function appendContinuationAndJournal(
+  messages: EngineMessage[],
+  reason: AgentLoopContinuationReason,
+  threadId: string | undefined,
+  localEvents: readonly AgentChatEvent[] = [],
+): Promise<void> {
+  const events = await readCurrentTurnEventsForResume(threadId, localEvents);
+  appendAgentLoopContinuation(
+    messages,
+    reason,
+    actionPreparationContinuationOptions(events),
+  );
+  appendToolCallJournalNote(messages, events);
+}
+
 async function hasCompletedSideEffectToolCallInCurrentTurn(
   threadId: string | undefined,
+  localEvents: readonly AgentChatEvent[] = [],
 ): Promise<boolean> {
-  if (!threadId) return false;
   try {
-    const events = await getCurrentTurnEventsForThread(threadId);
+    const events = await readCurrentTurnEventsForResume(threadId, localEvents);
     if (events.length === 0) return false;
     return events.some(
       (event) =>
@@ -97,6 +141,24 @@ async function hasCompletedSideEffectToolCallInCurrentTurn(
   }
 }
 
+function internalContinuationReasonForAttempt(
+  events: readonly AgentChatEvent[],
+): AgentLoopContinuationReason | undefined {
+  const last = events.at(-1);
+  if (last?.type !== "auto_continue") return undefined;
+  if (
+    last.reason === "run_timeout" ||
+    last.reason === "loop_limit" ||
+    last.reason === "no_progress" ||
+    last.reason === "stream_ended" ||
+    last.reason === "gateway_timeout" ||
+    last.reason === "network_interrupted"
+  ) {
+    return last.reason;
+  }
+  return undefined;
+}
+
 /**
  * Cap on continuation iterations inside a single
  * `runAgentLoopDirectWithSoftTimeout` invocation. The host's hard function
@@ -161,6 +223,7 @@ export async function runAgentLoopDirectWithSoftTimeout(
     usage.model = next.model;
   };
 
+  const localTurnEvents: AgentChatEvent[] = [];
   let attempts = 0;
   // Tracks whether the most recent attempt ended by scheduling another
   // continuation (soft-timeout or resumable error → `continue`) rather than
@@ -189,16 +252,49 @@ export async function runAgentLoopDirectWithSoftTimeout(
       controller.abort();
     }, timeoutMs);
 
+    const attemptStartIndex = localTurnEvents.length;
+    const send = (event: AgentChatEvent) => {
+      localTurnEvents.push(event);
+      opts.send(event);
+    };
+
     try {
       const nextUsage = await runAgentLoop({
         ...opts,
+        send,
         signal: controller.signal,
       });
       addUsage(nextUsage);
+      const attemptEvents = localTurnEvents.slice(attemptStartIndex);
+      const internalContinuationReason =
+        internalContinuationReasonForAttempt(attemptEvents);
+      if (internalContinuationReason && !upstreamSignal.aborted) {
+        lastAttemptWasUnfinishedContinuation = true;
+        const continuationEvents = [...localTurnEvents];
+        if (
+          !(await hasCompletedSideEffectToolCallInCurrentTurn(
+            opts.threadId,
+            continuationEvents,
+          ))
+        ) {
+          opts.send({ type: "clear" });
+        }
+        await appendContinuationAndJournal(
+          opts.messages,
+          internalContinuationReason,
+          opts.threadId,
+          continuationEvents,
+        );
+        continue;
+      }
       if (softTimedOut && !upstreamSignal.aborted) {
         lastAttemptWasUnfinishedContinuation = true;
-        appendAgentLoopContinuation(opts.messages, "run_timeout");
-        await appendToolCallJournalNote(opts.messages, opts.threadId);
+        await appendContinuationAndJournal(
+          opts.messages,
+          "run_timeout",
+          opts.threadId,
+          localTurnEvents,
+        );
         continue;
       }
       return usage;
@@ -208,12 +304,19 @@ export async function runAgentLoopDirectWithSoftTimeout(
         // resumed model doesn't re-emit it and produce duplicated output.
         lastAttemptWasUnfinishedContinuation = true;
         if (
-          !(await hasCompletedSideEffectToolCallInCurrentTurn(opts.threadId))
+          !(await hasCompletedSideEffectToolCallInCurrentTurn(
+            opts.threadId,
+            localTurnEvents,
+          ))
         ) {
           opts.send({ type: "clear" });
         }
-        appendAgentLoopContinuation(opts.messages, "run_timeout");
-        await appendToolCallJournalNote(opts.messages, opts.threadId);
+        await appendContinuationAndJournal(
+          opts.messages,
+          "run_timeout",
+          opts.threadId,
+          localTurnEvents,
+        );
         continue;
       }
       // Resumable transport / gateway interruptions: the LLM call was cut off
@@ -232,15 +335,19 @@ export async function runAgentLoopDirectWithSoftTimeout(
       if (!upstreamSignal.aborted && isResumableEngineError(err)) {
         lastAttemptWasUnfinishedContinuation = true;
         if (
-          !(await hasCompletedSideEffectToolCallInCurrentTurn(opts.threadId))
+          !(await hasCompletedSideEffectToolCallInCurrentTurn(
+            opts.threadId,
+            localTurnEvents,
+          ))
         ) {
           opts.send({ type: "clear" });
         }
-        appendAgentLoopContinuation(
+        await appendContinuationAndJournal(
           opts.messages,
           continuationReasonForResumableError(err),
+          opts.threadId,
+          localTurnEvents,
         );
-        await appendToolCallJournalNote(opts.messages, opts.threadId);
         continue;
       }
       throw err;
@@ -262,7 +369,12 @@ export async function runAgentLoopDirectWithSoftTimeout(
     // the terminal message stands alone instead of trailing a half sentence.
     // Preserve completed tool cards: they are the user's only durable proof
     // that a side effect landed before the final assistant note timed out.
-    if (!(await hasCompletedSideEffectToolCallInCurrentTurn(opts.threadId))) {
+    if (
+      !(await hasCompletedSideEffectToolCallInCurrentTurn(
+        opts.threadId,
+        localTurnEvents,
+      ))
+    ) {
       opts.send({ type: "clear" });
     }
     opts.send({

package/corpus/core/src/agent/types.ts

@@ -163,6 +163,14 @@ export interface AgentChatRequest {
   __backgroundRun?: {
     runId: string;
     turnId?: string;
+    continuationReason?:
+      | "run_timeout"
+      | "loop_limit"
+      | "no_progress"
+      | "stream_ended"
+      | "gateway_timeout"
+      | "network_interrupted";
+    actionPreparationTool?: string;
     /**
      * Number of server-driven background→background continuations already
      * chained into this logical turn (0 on the first chunk). The worker