deepline 0.1.21 → 0.1.23

package/dist/index.mjs

@@ -195,7 +195,7 @@ function resolveConfig(options) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.21";
+var SDK_VERSION = "0.1.23";
 var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
@@ -483,11 +483,24 @@ function sleep(ms) {
 // src/client.ts
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 var INCLUDE_TOOL_METADATA_HEADER = "x-deepline-include-tool-metadata";
+var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function isTransientCompileManifestError(error) {
+  if (error instanceof DeeplineError && typeof error.statusCode === "number") {
+    return error.statusCode === 408 || error.statusCode === 425 || error.statusCode === 499 || error.statusCode >= 500 && error.statusCode < 600;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return /fetch failed|connection (?:closed|reset|terminated)|socket hang up|econnreset|etimedout|eai_again|abort/i.test(
+    message
+  );
+}
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function normalizePlayStatus(raw) {
-  const status = typeof raw.status === "string" ? raw.status : typeof raw.temporalStatus === "string" ? mapLegacyTemporalStatus(raw.temporalStatus) : "running";
+  const status = typeof raw.status === "string" ? raw.status : "running";
   const runId = typeof raw.runId === "string" ? raw.runId : typeof raw.workflowId === "string" ? raw.workflowId : "";
   return {
     ...raw,
@@ -495,23 +508,6 @@ function normalizePlayStatus(raw) {
     status
   };
 }
-function mapLegacyTemporalStatus(status) {
-  switch (status.trim().toUpperCase()) {
-    case "PENDING":
-      return "queued";
-    case "COMPLETED":
-      return "completed";
-    case "FAILED":
-      return "failed";
-    case "CANCELLED":
-    case "TERMINATED":
-    case "TIMED_OUT":
-      return "cancelled";
-    case "RUNNING":
-    default:
-      return "running";
-  }
-}
 function decodeBase64Bytes(value) {
   const binary = atob(value);
   const bytes = new Uint8Array(binary.length);
@@ -520,6 +516,79 @@ function decodeBase64Bytes(value) {
   }
   return bytes;
 }
+function readStringArray(value) {
+  return Array.isArray(value) ? value.filter((line) => typeof line === "string") : [];
+}
+function getPlayLiveEventPayload(event) {
+  return event.payload && typeof event.payload === "object" ? event.payload : {};
+}
+function normalizeLiveStatus(value) {
+  if (value === "queued" || value === "running" || value === "waiting" || value === "completed" || value === "failed" || value === "cancelled") {
+    return value;
+  }
+  return null;
+}
+function updatePlayLiveStatusState(state, event) {
+  const payload = getPlayLiveEventPayload(event);
+  if (event.type === "play.run.log") {
+    state.logs.push(...readStringArray(payload.lines));
+    return null;
+  }
+  if (event.type !== "play.run.snapshot" && event.type !== "play.run.status" && event.type !== "play.run.final_status") {
+    return null;
+  }
+  const runId = typeof payload.runId === "string" && payload.runId ? payload.runId : state.runId;
+  const status = normalizeLiveStatus(payload.status) ?? state.status;
+  const logs = readStringArray(payload.logs);
+  if (logs.length > 0 || event.type === "play.run.snapshot") {
+    state.logs = logs;
+  }
+  if ("result" in payload) {
+    state.result = payload.result;
+  }
+  if (typeof payload.error === "string" && payload.error.trim()) {
+    state.error = payload.error;
+  }
+  state.runId = runId;
+  state.status = status;
+  const progressRecord = payload.progress && typeof payload.progress === "object" && !Array.isArray(payload.progress) ? payload.progress : {};
+  const next = {
+    ...payload,
+    runId,
+    status,
+    progress: {
+      ...progressRecord,
+      status: typeof progressRecord.status === "string" ? progressRecord.status : status,
+      logs: state.logs,
+      ...state.error ? { error: state.error } : {}
+    },
+    ..."result" in state ? { result: state.result } : {}
+  };
+  state.latest = next;
+  return next;
+}
+function playRunResultFromStatus(status, startedAt, fallbackRunId) {
+  return {
+    success: status.status === "completed",
+    runId: status.runId || fallbackRunId,
+    result: status.result,
+    logs: status.progress?.logs ?? [],
+    durationMs: Date.now() - startedAt,
+    error: status.progress?.error ?? (status.status !== "completed" ? status.status : void 0)
+  };
+}
+function playRunStatusFromState(state) {
+  return {
+    runId: state.runId,
+    status: state.status,
+    progress: {
+      status: state.status,
+      logs: state.logs,
+      ...state.error ? { error: state.error } : {}
+    },
+    ..."result" in state ? { result: state.result } : {}
+  };
+}
 var DeeplineClient = class {
   http;
   config;
@@ -629,7 +698,7 @@ var DeeplineClient = class {
   /**
    * Search available tools using Deepline's ranked backend search.
    *
-   * This is the same discovery surface used by the legacy CLI: it ranks across
+   * This is the same discovery surface used by the CLI: it ranks across
    * tool metadata, categories, agent guidance, and input schema fields.
    */
   async searchTools(options = {}) {
@@ -722,7 +791,7 @@ var DeeplineClient = class {
    * `progress.logs`; they are not part of the user output object.
    *
    * @param request - Play run configuration (name, code, input, etc.)
-   * @returns Workflow metadata including the `workflowId` for status polling
+   * @returns Run metadata including the public `workflowId`
    *
    * @example
    * ```typescript
@@ -832,8 +901,22 @@ var DeeplineClient = class {
     });
   }
   async compilePlayManifest(input) {
-    const response = await this.http.post("/api/v2/plays/compile-manifest", input);
-    return response.compilerManifest;
+    const retryDelays = COMPILE_MANIFEST_RETRY_DELAYS_MS.slice(
+      0,
+      Math.max(0, this.config.maxRetries)
+    );
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        const response = await this.http.post("/api/v2/plays/compile-manifest", input);
+        return response.compilerManifest;
+      } catch (error) {
+        const delayMs = retryDelays[attempt];
+        if (delayMs === void 0 || !isTransientCompileManifestError(error)) {
+          throw error;
+        }
+        await sleep2(delayMs);
+      }
+    }
   }
   /**
    * Check a bundled play artifact against the server's current play compiler.
@@ -1014,9 +1097,6 @@ var DeeplineClient = class {
    * Internal/advanced primitive. Public callers should usually prefer
    * {@link runPlay}, {@link PlayJob.get}, or `deepline play run --watch`.
    *
-   * Poll this method until `status` reaches a terminal state:
-   * `'completed'`, `'failed'`, or `'cancelled'`.
-   *
    * @param workflowId - Play-run id from {@link startPlayRun}
    * @returns Current status with progress logs and partial results
    *
@@ -1038,35 +1118,11 @@ var DeeplineClient = class {
     );
     return normalizePlayStatus(response);
   }
-  /**
-   * Get the lightweight tail-polling status for a play execution.
-   *
-   * This is intentionally smaller than {@link getPlayStatus}: it returns the
-   * fields needed for CLI log tailing while the run is in flight, without
-   * forcing the API to rebuild final result views on every poll. Call
-   * {@link getPlayStatus} once after a terminal state for the full result.
-   */
-  async getPlayTailStatus(workflowId, options) {
-    const params = new URLSearchParams({ mode: "tail" });
-    if (typeof options?.afterLogIndex === "number") {
-      params.set("afterLogIndex", String(options.afterLogIndex));
-    }
-    if (typeof options?.waitMs === "number") {
-      params.set("waitMs", String(options.waitMs));
-    }
-    if (options?.terminalOnly) {
-      params.set("terminalOnly", "true");
-    }
-    const response = await this.http.get(
-      `/api/v2/plays/run/${encodeURIComponent(workflowId)}?${params.toString()}`
-    );
-    return normalizePlayStatus(response);
-  }
   /**
    * Stream semantic play-run events using the same SSE feed as the dashboard.
    *
-   * Consumers should still keep a polling fallback: SSE is the fast live-update
-   * transport, while the status endpoints remain the authoritative recovery path.
+   * The server emits a canonical `play.run.snapshot` event first for every
+   * connection, then incremental live events until terminal state or reconnect.
    */
   async *streamPlayRunEvents(workflowId, options) {
     const headers = options?.lastEventId && options.lastEventId.trim() ? { "Last-Event-ID": options.lastEventId.trim() } : void 0;
@@ -1086,7 +1142,7 @@ var DeeplineClient = class {
    *
    * Sends a stop request for the run.
    *
-   * @param workflowId - Temporal workflow ID to cancel
+   * @param workflowId - Public Deepline play-run id to cancel
    *
    * @example
    * ```typescript
@@ -1102,7 +1158,7 @@ var DeeplineClient = class {
   /**
    * Stop a running play execution, including open HITL waits.
    *
-   * @param workflowId - Temporal workflow ID to stop
+   * @param workflowId - Public Deepline play-run id to stop
    * @param options.reason - Optional audit/debug reason
    */
   async stopPlay(workflowId, options) {
@@ -1174,32 +1230,42 @@ var DeeplineClient = class {
     );
     return response.runs ?? [];
   }
-  /**
-   * Fetch the lightweight tail status for a run using the public runs resource model.
-   *
-   * This is the SDK equivalent of:
-   *
-   * ```bash
-   * deepline runs tail <run-id> --json
-   * ```
-   */
+  /** Read the canonical run stream and return the latest run snapshot. */
   async tailRun(runId, options) {
-    const afterLogIndex = typeof options?.afterLogIndex === "number" ? options.afterLogIndex : typeof options?.cursor === "number" ? options.cursor : typeof options?.cursor === "string" && options.cursor.trim() ? Number(options.cursor) : void 0;
-    const params = new URLSearchParams();
-    if (Number.isFinite(afterLogIndex)) {
-      params.set("afterLogIndex", String(Number(afterLogIndex)));
+    const state = {
+      runId,
+      status: "running",
+      logs: [],
+      latest: null
+    };
+    let terminal = false;
+    for await (const event of this.streamPlayRunEvents(runId, {
+      mode: "cli",
+      signal: options?.signal
+    })) {
+      const status = updatePlayLiveStatusState(state, event);
+      if (!status) {
+        continue;
+      }
+      terminal = TERMINAL_PLAY_STATUSES.has(status.status);
+      if (terminal) {
+        break;
+      }
     }
-    if (typeof options?.waitMs === "number") {
-      params.set("waitMs", String(options.waitMs));
+    if (terminal && state.latest) {
+      return await this.getRunStatus(state.latest.runId || runId).catch(
+        () => state.latest ?? playRunStatusFromState(state)
+      );
     }
-    if (options?.terminalOnly) {
-      params.set("terminalOnly", "true");
+    if (state.latest) {
+      return state.latest;
     }
-    const suffix = params.toString() ? `?${params.toString()}` : "";
-    const response = await this.http.get(
-      `/api/v2/runs/${encodeURIComponent(runId)}/tail${suffix}`
+    throw new DeeplineError(
+      `Run stream for ${runId} ended before the initial snapshot.`,
+      void 0,
+      "PLAY_RUN_STREAM_EMPTY",
+      { runId }
     );
-    return normalizePlayStatus(response);
   }
   /**
    * Fetch persisted logs for a run using the public runs resource model.
@@ -1356,11 +1422,11 @@ var DeeplineClient = class {
   // Plays — high-level orchestration
   // ——————————————————————————————————————————————————————————
   /**
-   * Run a play end-to-end: submit, poll until terminal, return result.
+   * Run a play end-to-end: submit, stream until terminal, return result.
    *
    * This is the highest-level play execution method. It submits the play,
-   * polls for status updates, and returns a structured result with logs
-   * and timing. Supports cancellation via `AbortSignal`.
+   * reads the canonical run stream for status updates, and returns a structured
+   * result with logs and timing. Supports cancellation via `AbortSignal`.
    *
    * @param code - Source string fallback; pass the bundled artifact in `options.artifact`
    * @param csvPath - Input CSV path, or `null`
@@ -1376,7 +1442,6 @@ var DeeplineClient = class {
    *     const logs = status.progress?.logs ?? [];
    *     console.log(`[${status.status}] ${logs.length} log lines`);
    *   },
-   *   pollIntervalMs: 1000,
    * });
    *
    * if (result.success) {
@@ -1407,33 +1472,53 @@ var DeeplineClient = class {
       packagedFiles: options?.packagedFiles,
       force: options?.force
     });
-    const pollInterval = options?.pollIntervalMs ?? 500;
     const start = Date.now();
-    while (true) {
+    const state = {
+      runId: workflowId,
+      status: "running",
+      logs: [],
+      latest: null
+    };
+    if (options?.signal?.aborted) {
+      await this.cancelPlay(workflowId);
+      return {
+        success: false,
+        runId: workflowId,
+        logs: [],
+        durationMs: Date.now() - start,
+        error: "Cancelled by user"
+      };
+    }
+    for await (const event of this.streamPlayRunEvents(workflowId, {
+      mode: "cli",
+      signal: options?.signal
+    })) {
       if (options?.signal?.aborted) {
         await this.cancelPlay(workflowId);
         return {
           success: false,
           runId: workflowId,
-          logs: [],
+          logs: state.logs,
           durationMs: Date.now() - start,
           error: "Cancelled by user"
         };
       }
-      const status = await this.getPlayStatus(workflowId);
+      const status = updatePlayLiveStatusState(state, event);
+      if (!status) {
+        continue;
+      }
       options?.onProgress?.(status);
       if (TERMINAL_PLAY_STATUSES.has(status.status)) {
-        return {
-          success: status.status === "completed",
-          runId: status.runId || workflowId,
-          result: status.result,
-          logs: status.progress?.logs ?? [],
-          durationMs: Date.now() - start,
-          error: status.progress?.error ?? (status.status !== "completed" ? status.status : void 0)
-        };
+        const finalStatus = await this.getPlayStatus(status.runId || workflowId).catch(() => status);
+        return playRunResultFromStatus(finalStatus, start, workflowId);
       }
-      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
     }
+    throw new DeeplineError(
+      `Run stream for ${workflowId} ended before the run reached a terminal state.`,
+      void 0,
+      "PLAY_RUN_STREAM_ENDED",
+      { runId: workflowId, workflowId }
+    );
   }
   // ——————————————————————————————————————————————————————————
   // Health

package/dist/repo/apps/play-runner-workers/src/coordinator-entry.ts

@@ -3017,6 +3017,7 @@ async function handleWorkflowRoute(input: {
         error: terminalEvent.error ?? null,
         totalRows: terminalEvent.totalRows ?? null,
         durationMs: terminalEvent.durationMs ?? null,
+        completedAt: terminalEvent.ts,
         events: eventResult?.events ?? [],
         latestSeq: eventResult?.latestSeq ?? afterSeq,
         wait: null,
@@ -3147,6 +3148,7 @@ async function handleWorkflowRoute(input: {
           error: terminalState.error ?? null,
           totalRows: terminalState.totalRows ?? null,
           durationMs: terminalState.durationMs ?? null,
+          completedAt: terminalState.completedAt ?? null,
           wait: null,
           coordinatorObserve: {
             ms: Date.now() - statusStartedAt,
@@ -3229,7 +3231,7 @@ function stableHash(value: string): string {
 }
 
 const DYNAMIC_PLAY_WORKER_HARNESS_VERSION =
-  'h6-runtime-api-coordinator-deploy-scoped';
+  'h7-skip-high-volume-tool-traces';
 const DYNAMIC_WORKER_BUNDLED_CODE_CACHE_MAX_ENTRIES = 64;
 const dynamicWorkerBundledCodeCache = new Map<string, string>();
 

package/dist/repo/apps/play-runner-workers/src/entry.ts

@@ -524,6 +524,26 @@ type WorkflowRunOutput = {
   durationMs: number;
 };
 
+type LiveNodeProgressSnapshot = {
+  completed?: number;
+  total?: number;
+  failed?: number;
+  message?: string;
+  updatedAt?: number;
+  startedAt?: number;
+  completedAt?: number;
+  artifactTableNamespace?: string | null;
+};
+
+type LiveNodeProgressMap = Record<string, LiveNodeProgressSnapshot>;
+
+type WorkerCtxCallbacks = {
+  onNodeProgress?: (input: {
+    nodeId: string;
+    progress: LiveNodeProgressSnapshot;
+  }) => void;
+};
+
 function nowMs(): number {
   return Date.now();
 }
@@ -535,6 +555,12 @@ function recordRunnerPerfTrace(input: {
   extra?: Record<string, unknown>;
 }): void {
   if (!input.req.runId || !input.phase) return;
+  // Tool-level traces can fire once per row/provider step. Forwarding each one
+  // through the coordinator binding can consume Cloudflare's subrequest budget
+  // before large batched maps finish.
+  if (input.phase.startsWith('runner.tool.')) {
+    return;
+  }
   const payload = {
     ts: Date.now(),
     source: 'dynamic_worker' as const,
@@ -1092,6 +1118,29 @@ async function callToolDirect(
   let lastError: Error | null = null;
 
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    if (toolId === 'test_transient_500' || toolId === 'test_transient_429') {
+      const syntheticResult = executeSyntheticTransientRetry(
+        toolId,
+        input,
+        attempt,
+      );
+      if (syntheticResult.ok) {
+        return wrapWorkerToolResult(
+          toolId,
+          syntheticResult.result,
+          syntheticToolMetadata(toolId),
+        );
+      }
+      lastError = new Error(
+        `tool ${toolId} ${syntheticResult.status} attempt ${attempt}/${maxAttempts}: ${syntheticResult.message}`,
+      );
+      if (attempt >= maxAttempts) {
+        throw lastError;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1_000));
+      continue;
+    }
+
     const res = await fetchRuntimeApi(req.baseUrl, path, {
       method: 'POST',
       headers: {
@@ -1277,6 +1326,41 @@ async function executeSyntheticTestRateLimitBatch(
   };
 }
 
+type SyntheticTransientRetryResult =
+  | { ok: true; result: Record<string, unknown> }
+  | { ok: false; status: number; message: string };
+
+function executeSyntheticTransientRetry(
+  toolId: string,
+  input: Record<string, unknown>,
+  attempt: number,
+): SyntheticTransientRetryResult {
+  const failuresBeforeSuccess =
+    typeof input.failures_before_success === 'number' &&
+    Number.isInteger(input.failures_before_success) &&
+    input.failures_before_success >= 0
+      ? input.failures_before_success
+      : 1;
+  if (attempt <= failuresBeforeSuccess) {
+    const status = toolId === 'test_transient_429' ? 429 : 502;
+    return {
+      ok: false,
+      status,
+      message: `Synthetic transient ${status} for attempt ${attempt}`,
+    };
+  }
+  return {
+    ok: true,
+    result: {
+      status: 'completed',
+      provider: 'test',
+      key: String(input.key ?? 'transient'),
+      attempts: attempt,
+      recovered: attempt > 1,
+    },
+  };
+}
+
 function executeSyntheticTestRateLimit(
   input: Record<string, unknown>,
 ): Record<string, unknown> {
@@ -2561,6 +2645,7 @@ function createMinimalWorkerCtx(
   env: WorkerEnv,
   workflowStep?: WorkflowStep,
   abortSignal?: AbortSignal,
+  callbacks?: WorkerCtxCallbacks,
 ): unknown {
   let playCallCount = 0;
   const parentChildCalls: Record<string, number> = {};
@@ -2635,6 +2720,7 @@ function createMinimalWorkerCtx(
     opts?: WorkerMapOptions,
   ): Promise<unknown> => {
     const mapStartedAt = nowMs();
+    const mapNodeId = `map:${name}`;
     const sliced = rows;
     const baseOffset = 0;
     const fieldEntries = Object.entries(fieldsDef);
@@ -2655,6 +2741,30 @@ function createMinimalWorkerCtx(
       softWorkflowStepBudget: plan?.chunkPlan.softWorkflowStepBudget,
     });
     const outputFields = fieldEntries.map(([field]) => field);
+    const updateMapProgress = (progress: LiveNodeProgressSnapshot) => {
+      callbacks?.onNodeProgress?.({
+        nodeId: mapNodeId,
+        progress: {
+          artifactTableNamespace: name,
+          failed: 0,
+          ...progress,
+          updatedAt: progress.updatedAt ?? nowMs(),
+        },
+      });
+    };
+    const formatMapProgressMessage = (completed: number, total?: number) =>
+      typeof total === 'number' && Number.isFinite(total) && total > 0
+        ? `${completed.toLocaleString()} / ${total.toLocaleString()} rows processed`
+        : `${completed.toLocaleString()} rows processed`;
+    updateMapProgress({
+      completed: 0,
+      total: streaming ? undefined : sliced.length,
+      startedAt: mapStartedAt,
+      message: formatMapProgressMessage(
+        0,
+        streaming ? undefined : sliced.length,
+      ),
+    });
     const explicitRowKeysSeen =
       opts?.key === undefined ? null : new Map<string, number>();
     const resolveExplicitKeyValue = (
@@ -3156,6 +3266,14 @@ function createMinimalWorkerCtx(
         `Map completed: ${totalRowsWritten} results ` +
         `(${totalRowsExecuted} executed, ${totalRowsCached} already satisfied) ` +
         `inserted=${totalRowsInserted} skipped=${totalRowsSkipped}`;
+      const completedAt = nowMs();
+      updateMapProgress({
+        completed: totalRowsWritten,
+        total: totalRowsWritten,
+        completedAt,
+        updatedAt: completedAt,
+        message: formatMapProgressMessage(totalRowsWritten, totalRowsWritten),
+      });
       emitEvent({
         type: 'log',
         level: 'info',
@@ -3199,6 +3317,10 @@ function createMinimalWorkerCtx(
         totalRowsDuplicateReused += chunkResult.rowsDuplicateReused;
         totalRowsInserted += chunkResult.rowsInserted;
         totalRowsSkipped += chunkResult.rowsSkipped;
+        updateMapProgress({
+          completed: totalRowsWritten,
+          message: formatMapProgressMessage(totalRowsWritten),
+        });
         if (out.length < 10) {
           out.push(...chunkResult.preview.slice(0, 10 - out.length));
         }
@@ -3230,6 +3352,11 @@ function createMinimalWorkerCtx(
         totalRowsDuplicateReused += chunkResult.rowsDuplicateReused;
         totalRowsInserted += chunkResult.rowsInserted;
         totalRowsSkipped += chunkResult.rowsSkipped;
+        updateMapProgress({
+          completed: totalRowsWritten,
+          total: sliced.length,
+          message: formatMapProgressMessage(totalRowsWritten, sliced.length),
+        });
         if (out.length < 10) {
           out.push(...chunkResult.preview.slice(0, 10 - out.length));
         }
@@ -3252,6 +3379,11 @@ function createMinimalWorkerCtx(
     totalRowsInserted = chunkResult.rowsInserted;
     totalRowsSkipped = chunkResult.rowsSkipped;
     out.push(...chunkResult.preview);
+    updateMapProgress({
+      completed: chunkResult.rowsWritten,
+      total: sliced.length,
+      message: formatMapProgressMessage(chunkResult.rowsWritten, sliced.length),
+    });
     const dataset = finalize(chunkResult.rowsWritten);
     recordRunnerPerfTrace({
       req,
@@ -3919,6 +4051,7 @@ async function executeRunRequest(
   // sees the final terminal status with no intermediate logs/progress.
   let liveLogs: string[] = [];
   let liveLogsDirty = false;
+  let liveNodeProgress: LiveNodeProgressMap = {};
   let lastLiveLogFlushAt =
     nowMs() - LIVE_LOG_FLUSH_INTERVAL_MS + LIVE_LOG_FIRST_FLUSH_DELAY_MS;
   let liveLogFlushInFlight: Promise<void> = Promise.resolve();
@@ -3928,6 +4061,21 @@ async function executeRunRequest(
     liveLogs = [...liveLogs, trimmed].slice(-LIVE_LOG_BUFFER_LIMIT);
     liveLogsDirty = true;
   };
+  const updateLiveNodeProgress = (input: {
+    nodeId: string;
+    progress: LiveNodeProgressSnapshot;
+  }) => {
+    const nodeId = input.nodeId.trim();
+    if (!nodeId) return;
+    liveNodeProgress = {
+      ...liveNodeProgress,
+      [nodeId]: {
+        ...(liveNodeProgress[nodeId] ?? {}),
+        ...input.progress,
+      },
+    };
+  };
+  const liveNodeProgressSnapshot = () => ({ ...liveNodeProgress });
   const flushLiveLogs = (force: boolean): void => {
     if (!options?.persistResultDatasets) return;
     if (!liveLogsDirty && !force) return;
@@ -3946,6 +4094,7 @@ async function executeRunRequest(
             status: 'running',
             runtimeBackend: 'cf_workflows_dynamic_worker',
             liveLogs: snapshot,
+            liveNodeProgress: liveNodeProgressSnapshot(),
             lastCheckpointAt: now,
           });
         } catch {
@@ -3975,6 +4124,7 @@ async function executeRunRequest(
     env,
     workflowStep,
     abortSignal,
+    { onNodeProgress: updateLiveNodeProgress },
   );
   try {
     const playStartedAt = nowMs();
@@ -4017,12 +4167,14 @@ async function executeRunRequest(
         action: 'update_run_status',
         playId: req.runId,
         status: 'completed',
+        error: null,
         result: terminalResult,
         runtimeBackend: 'cf_workflows_dynamic_worker',
         waitKind: null,
         waitUntil: null,
         activeBoundaryId: null,
         liveLogs,
+        liveNodeProgress: liveNodeProgressSnapshot(),
         lastCheckpointAt: nowMs(),
       });
       recordRunnerPerfTrace({
@@ -4092,6 +4244,7 @@ async function executeRunRequest(
         waitUntil: null,
         activeBoundaryId: null,
         liveLogs,
+        liveNodeProgress: liveNodeProgressSnapshot(),
         lastCheckpointAt: nowMs(),
       });
       await finalizeWorkerComputeBilling({