@qwen-code/qwen-code 0.19.12-preview.0 → 0.20.0-nightly.20260720.0c271659d

package/chunks/chunk-27AJEU6G.js

@@ -0,0 +1,442 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  sanitizeFilenameForDisplay
+} from "./chunk-RS7MT2QG.js";
+import {
+  t
+} from "./chunk-3QR5MOHP.js";
+import {
+  fetchGitDiff,
+  findProviderByCredentials,
+  resolveMetadataKey
+} from "./chunk-JDPCOUZ3.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/utils/computeStats.ts
+init_esbuild_shims();
+function calculateErrorRate(metrics) {
+  if (metrics.api.totalRequests === 0) {
+    return 0;
+  }
+  return metrics.api.totalErrors / metrics.api.totalRequests * 100;
+}
+__name(calculateErrorRate, "calculateErrorRate");
+function calculateAverageLatency(metrics) {
+  if (metrics.api.totalRequests === 0) {
+    return 0;
+  }
+  return metrics.api.totalLatencyMs / metrics.api.totalRequests;
+}
+__name(calculateAverageLatency, "calculateAverageLatency");
+function calculateCacheHitRate(metrics) {
+  if (metrics.tokens.prompt === 0) {
+    return 0;
+  }
+  return metrics.tokens.cached / metrics.tokens.prompt * 100;
+}
+__name(calculateCacheHitRate, "calculateCacheHitRate");
+var computeSessionStats = /* @__PURE__ */ __name((metrics) => {
+  const { models, tools, files } = metrics;
+  const totalApiTime = Object.values(models).reduce(
+    (acc, model) => acc + model.api.totalLatencyMs,
+    0
+  );
+  const totalToolTime = tools.totalDurationMs;
+  const agentActiveTime = totalApiTime + totalToolTime;
+  const apiTimePercent = agentActiveTime > 0 ? totalApiTime / agentActiveTime * 100 : 0;
+  const toolTimePercent = agentActiveTime > 0 ? totalToolTime / agentActiveTime * 100 : 0;
+  const totalCachedTokens = Object.values(models).reduce(
+    (acc, model) => acc + model.tokens.cached,
+    0
+  );
+  const totalPromptTokens = Object.values(models).reduce(
+    (acc, model) => acc + model.tokens.prompt,
+    0
+  );
+  const cacheEfficiency = totalPromptTokens > 0 ? totalCachedTokens / totalPromptTokens * 100 : 0;
+  const totalDecisions = tools.totalDecisions.accept + tools.totalDecisions.reject + tools.totalDecisions.modify;
+  const successRate = tools.totalCalls > 0 ? tools.totalSuccess / tools.totalCalls * 100 : 0;
+  const agreementRate = totalDecisions > 0 ? tools.totalDecisions.accept / totalDecisions * 100 : 0;
+  return {
+    totalApiTime,
+    totalToolTime,
+    agentActiveTime,
+    apiTimePercent,
+    toolTimePercent,
+    cacheEfficiency,
+    totalDecisions,
+    successRate,
+    agreementRate,
+    totalCachedTokens,
+    totalPromptTokens,
+    totalLinesAdded: files.totalLinesAdded,
+    totalLinesRemoved: files.totalLinesRemoved
+  };
+}, "computeSessionStats");
+
+// packages/cli/src/services/commandUtils.ts
+init_esbuild_shims();
+function getEffectiveSupportedModes(cmd) {
+  if (cmd.supportedModes !== void 0) {
+    return cmd.supportedModes;
+  }
+  switch (cmd.kind) {
+    case "built-in" /* BUILT_IN */:
+      return ["interactive"];
+    case "file" /* FILE */:
+    case "skill" /* SKILL */:
+    case "mcp-prompt" /* MCP_PROMPT */:
+      return ["interactive", "non_interactive", "acp"];
+    default:
+      return ["interactive"];
+  }
+}
+__name(getEffectiveSupportedModes, "getEffectiveSupportedModes");
+function filterCommandsForMode(commands, mode) {
+  return commands.filter(
+    (cmd) => getEffectiveSupportedModes(cmd).includes(mode)
+  );
+}
+__name(filterCommandsForMode, "filterCommandsForMode");
+
+// packages/cli/src/ui/commands/diffCommand.ts
+init_esbuild_shims();
+async function diffAction(context) {
+  const { config } = context.services;
+  if (!config) {
+    return {
+      type: "message",
+      messageType: "error",
+      content: t("Configuration not available.")
+    };
+  }
+  if (context.executionMode === "interactive") {
+    return { type: "dialog", dialog: "diff" };
+  }
+  const cwd = config.getWorkingDir() || config.getProjectRoot();
+  if (!cwd) {
+    return {
+      type: "message",
+      messageType: "error",
+      content: t("Could not determine current working directory.")
+    };
+  }
+  let result;
+  try {
+    result = await fetchGitDiff(cwd);
+  } catch (error) {
+    return {
+      type: "message",
+      messageType: "error",
+      content: `${t("Failed to compute git diff stats")}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (!result) {
+    return {
+      type: "message",
+      messageType: "info",
+      content: t(
+        "No diff available. Either this is not a git repository, HEAD is missing, or a merge/rebase/cherry-pick/revert is in progress."
+      )
+    };
+  }
+  if (result.stats.filesCount === 0) {
+    return {
+      type: "message",
+      messageType: "info",
+      content: t("Clean working tree \u2014 no changes against HEAD.")
+    };
+  }
+  const model = buildDiffRenderModel(result);
+  return {
+    type: "message",
+    messageType: "info",
+    content: renderDiffModelText(model)
+  };
+}
+__name(diffAction, "diffAction");
+function buildDiffRenderModel(result) {
+  const rows = [];
+  for (const [filename, s] of result.perFileStats) {
+    rows.push(toRow(filename, s));
+  }
+  const hiddenCount = Math.max(0, result.stats.filesCount - rows.length);
+  return {
+    filesCount: result.stats.filesCount,
+    linesAdded: result.stats.linesAdded,
+    linesRemoved: result.stats.linesRemoved,
+    rows,
+    hiddenCount
+  };
+}
+__name(buildDiffRenderModel, "buildDiffRenderModel");
+function toRow(filename, s) {
+  if (s.isBinary) {
+    return {
+      filename,
+      oldPath: s.oldPath,
+      isBinary: true,
+      isUntracked: Boolean(s.isUntracked),
+      isDeleted: Boolean(s.isDeleted),
+      truncated: false
+    };
+  }
+  return {
+    filename,
+    oldPath: s.oldPath,
+    added: s.added,
+    removed: s.isUntracked ? 0 : s.removed,
+    isBinary: false,
+    isUntracked: Boolean(s.isUntracked),
+    isDeleted: Boolean(s.isDeleted),
+    truncated: Boolean(s.truncated)
+  };
+}
+__name(toRow, "toRow");
+function computeDiffColumnWidths(rows) {
+  let maxAdded = 0;
+  let maxRemoved = 0;
+  for (const r of rows) {
+    if (r.isBinary) continue;
+    if ((r.added ?? 0) > maxAdded) maxAdded = r.added ?? 0;
+    if ((r.removed ?? 0) > maxRemoved) maxRemoved = r.removed ?? 0;
+  }
+  const addWidth = String(maxAdded).length;
+  const remWidth = String(maxRemoved).length;
+  const statColumnWidth = 1 + addWidth + 1 + 1 + remWidth;
+  return { addWidth, remWidth, statColumnWidth };
+}
+__name(computeDiffColumnWidths, "computeDiffColumnWidths");
+function renderDiffModelText(model) {
+  const { filesCount, linesAdded, linesRemoved, rows, hiddenCount } = model;
+  const header = filesCount === 1 ? t("{{count}} file changed, +{{added}} / -{{removed}}", {
+    count: String(filesCount),
+    added: String(linesAdded),
+    removed: String(linesRemoved)
+  }) : t("{{count}} files changed, +{{added}} / -{{removed}}", {
+    count: String(filesCount),
+    added: String(linesAdded),
+    removed: String(linesRemoved)
+  });
+  const lines = formatRowsText(rows);
+  const capNote = hiddenCount > 0 && rows.length > 0 ? `
+  ${t("\u2026and {{hidden}} more (showing first {{shown}})", {
+    hidden: String(hiddenCount),
+    shown: String(rows.length)
+  })}` : "";
+  return lines.length > 0 ? `${header}
+${lines.join("\n")}${capNote}` : header;
+}
+__name(renderDiffModelText, "renderDiffModelText");
+function formatRowsText(rows) {
+  if (rows.length === 0) return [];
+  const { addWidth, remWidth, statColumnWidth } = computeDiffColumnWidths(rows);
+  const out = [];
+  for (const r of rows) {
+    const safeName = sanitizeFilenameForDisplay(r.filename);
+    const displayName = r.oldPath ? `${sanitizeFilenameForDisplay(r.oldPath)} \u2192 ${safeName}` : safeName;
+    if (r.isBinary) {
+      const suffix2 = r.isUntracked ? ` ${t("(binary, new)")}` : r.isDeleted ? ` ${t("(binary, deleted)")}` : ` ${t("(binary)")}`;
+      out.push(`  ${padMarker("~", statColumnWidth)}  ${displayName}${suffix2}`);
+      continue;
+    }
+    const added = `+${String(r.added ?? 0).padStart(addWidth)}`;
+    const removed = `-${String(r.removed ?? 0).padStart(remWidth)}`;
+    let suffix = "";
+    if (r.isUntracked) {
+      suffix = r.truncated ? ` ${t("(new, partial)")}` : ` ${t("(new)")}`;
+    } else if (r.isDeleted) {
+      suffix = ` ${t("(deleted)")}`;
+    }
+    out.push(`  ${added} ${removed}  ${displayName}${suffix}`);
+  }
+  return out;
+}
+__name(formatRowsText, "formatRowsText");
+function padMarker(marker, width) {
+  if (marker.length >= width) return marker;
+  return `${marker}${" ".repeat(width - marker.length)}`;
+}
+__name(padMarker, "padMarker");
+var diffCommand = {
+  name: "diff",
+  get description() {
+    return t("Show working-tree change stats versus HEAD");
+  },
+  kind: "built-in" /* BUILT_IN */,
+  supportedModes: ["interactive", "non_interactive", "acp"],
+  action: diffAction
+};
+
+// packages/cli/src/utils/systemInfoFields.ts
+init_esbuild_shims();
+function getSystemInfoFields(info) {
+  const fields = [];
+  addField(fields, t("Qwen Code"), formatCliVersion(info));
+  addField(fields, t("Runtime"), formatRuntime(info));
+  addField(fields, t("IDE Client"), info.ideClient);
+  addField(fields, "LSP", info.lspStatus ?? "");
+  addField(fields, t("OS"), formatOs(info));
+  addField(fields, t("Auth"), formatAuth(info));
+  addField(fields, t("Base URL"), formatBaseUrl(info));
+  addField(fields, t("Model"), info.modelVersion);
+  addField(fields, t("Fast Model"), info.fastModel || info.modelVersion);
+  addField(fields, t("Session ID"), info.sessionId);
+  addField(fields, t("Sandbox"), info.sandboxEnv);
+  addField(fields, t("Proxy"), formatProxy(info.proxy));
+  addField(fields, t("Memory Usage"), info.memoryUsage);
+  return fields;
+}
+__name(getSystemInfoFields, "getSystemInfoFields");
+function addField(fields, label, value) {
+  if (value) {
+    fields.push({ label, value });
+  }
+}
+__name(addField, "addField");
+function formatCliVersion(info) {
+  if (!info.cliVersion) {
+    return "";
+  }
+  if (!info.gitCommit) {
+    return info.cliVersion;
+  }
+  return `${info.cliVersion} (${info.gitCommit})`;
+}
+__name(formatCliVersion, "formatCliVersion");
+function formatRuntime(info) {
+  if (!info.nodeVersion && !info.npmVersion) {
+    return "";
+  }
+  const node = info.nodeVersion ? `Node.js ${info.nodeVersion}` : "";
+  const npm = info.npmVersion ? `npm ${info.npmVersion}` : "";
+  return joinParts([node, npm], " / ");
+}
+__name(formatRuntime, "formatRuntime");
+function formatOs(info) {
+  return joinParts(
+    [info.osPlatform, info.osArch, formatOsRelease(info.osRelease)],
+    " "
+  ).trim();
+}
+__name(formatOs, "formatOs");
+function formatOsRelease(release) {
+  if (!release) {
+    return "";
+  }
+  return `(${release})`;
+}
+__name(formatOsRelease, "formatOsRelease");
+function formatAuth(info) {
+  if (!info.selectedAuthType) {
+    return "";
+  }
+  const managedProvider = findProviderByCredentials(
+    info.baseUrl,
+    info.apiKeyEnvKey
+  );
+  if (managedProvider && resolveMetadataKey(managedProvider)) {
+    return t(managedProvider.label);
+  }
+  if (info.selectedAuthType.startsWith("oauth") || info.selectedAuthType === "qwen-oauth") {
+    return "Qwen OAuth";
+  }
+  return `API Key - ${info.selectedAuthType}`;
+}
+__name(formatAuth, "formatAuth");
+function formatBaseUrl(info) {
+  if (!info.selectedAuthType || !info.baseUrl) {
+    return "";
+  }
+  if (info.selectedAuthType.startsWith("oauth") || info.selectedAuthType === "qwen-oauth") {
+    return "";
+  }
+  return info.baseUrl;
+}
+__name(formatBaseUrl, "formatBaseUrl");
+function formatProxy(proxy) {
+  if (!proxy) {
+    return "no proxy";
+  }
+  return redactProxy(proxy);
+}
+__name(formatProxy, "formatProxy");
+function redactProxy(proxy) {
+  try {
+    const url = new URL(proxy);
+    if (url.username || url.password) {
+      url.username = url.username ? "***" : "";
+      url.password = url.password ? "***" : "";
+    }
+    return url.toString();
+  } catch {
+    return proxy.replace(/\/\/[^/]*@/, "//***@");
+  }
+}
+__name(redactProxy, "redactProxy");
+function joinParts(parts, separator) {
+  return parts.filter((part) => part).join(separator);
+}
+__name(joinParts, "joinParts");
+
+// packages/cli/src/utils/costCalculator.ts
+init_esbuild_shims();
+function calculateCost(args) {
+  const { inputTokens, outputTokens, pricing } = args;
+  if (!pricing) return null;
+  const inputCost = pricing.inputPerMillionTokens != null ? inputTokens / 1e6 * pricing.inputPerMillionTokens : 0;
+  const outputCost = pricing.outputPerMillionTokens != null ? outputTokens / 1e6 * pricing.outputPerMillionTokens : 0;
+  const total = inputCost + outputCost;
+  return total > 0 ? total : null;
+}
+__name(calculateCost, "calculateCost");
+
+// packages/cli/src/ui/utils/skill-level-label.ts
+init_esbuild_shims();
+function levelLabel(level) {
+  switch (level) {
+    case "project":
+      return t("Project");
+    case "user":
+      return t("User");
+    case "extension":
+      return t("Extension");
+    case "bundled":
+      return t("Bundled");
+    default: {
+      const _exhaustive = level;
+      return _exhaustive;
+    }
+  }
+}
+__name(levelLabel, "levelLabel");
+
+export {
+  getSystemInfoFields,
+  calculateErrorRate,
+  calculateAverageLatency,
+  calculateCacheHitRate,
+  computeSessionStats,
+  calculateCost,
+  getEffectiveSupportedModes,
+  filterCommandsForMode,
+  levelLabel,
+  computeDiffColumnWidths,
+  diffCommand
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-53UMEONK.js → chunk-2HOVDT7W.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-MHEZV3OY.js";
+} from "./chunk-NIJEXGV6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-6WZZHJSZ.js → chunk-2JOLZA6L.js}

@@ -2,21 +2,21 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-PSISZNIT.js";
+} from "./chunk-Y5534U4G.js";
 import {
   assembleMcpServers,
   getPendingGatedMcpServers,
   getPromptableMcpServers
-} from "./chunk-PTXVHS2O.js";
+} from "./chunk-DCCW7CRR.js";
 import {
   getMCPServerStatus
-} from "./chunk-YN2I5I42.js";
+} from "./chunk-I6JUVU7J.js";
 import {
   require_fast_deep_equal
-} from "./chunk-ANRANWVE.js";
+} from "./chunk-OP4MOGXF.js";
 import {
   createDebugLogger
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-NSZJQACR.js → chunk-2TDSM7I6.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   scanForSecrets
-} from "./chunk-6TDA4EVC.js";
+} from "./chunk-JDPCOUZ3.js";
 import {
   isTeamAutoMemPath
-} from "./chunk-LPHGXXZX.js";
+} from "./chunk-JD3MKVKL.js";
 import {
   createDebugLogger
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-ILQ42UG6.js → chunk-2YJLFCYI.js}

@@ -21,12 +21,12 @@ import {
   getLanguageNameFromLocale,
   getLanguageSettingsOptions,
   t
-} from "./chunk-3PE7OY2G.js";
+} from "./chunk-3QR5MOHP.js";
 import {
   getHomeEnvFallbackVars,
   loadEnvironment,
   preResolveHomeEnvOverrides
-} from "./chunk-NGTQA57Y.js";
+} from "./chunk-NQVA6O7F.js";
 import {
   ENV_CORRUPTED_PATH,
   ENV_WAS_RECOVERED
@@ -34,7 +34,7 @@ import {
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-XFJU7SVP.js";
+} from "./chunk-RS5JPH6Y.js";
 import {
   require_strip_json_comments
 } from "./chunk-ALGGS7UH.js";
@@ -47,20 +47,20 @@ import {
   DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
   DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
   stripRuntimeSnapshotPrefix
-} from "./chunk-6TDA4EVC.js";
+} from "./chunk-JDPCOUZ3.js";
 import {
   DEFAULT_QWEN_CUSTOM_IGNORE_FILE_NAMES
-} from "./chunk-335ECZTA.js";
+} from "./chunk-ZEOZL37W.js";
 import {
   DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT
-} from "./chunk-YN2I5I42.js";
+} from "./chunk-I6JUVU7J.js";
 import {
   FatalConfigError,
   Storage,
   createDebugLogger,
   getErrorMessage
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-CMHJEUVB.js → chunk-37MGCVTS.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-DULSE2SH.js";
+} from "./chunk-COWNNAWJ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-F2YCCUXI.js → chunk-3ML52IFS.js}

@@ -5,13 +5,13 @@ import {
 } from "./chunk-E5Z2AVNV.js";
 import {
   getCliVersion
-} from "./chunk-W4DFAUAO.js";
+} from "./chunk-SQMTULHJ.js";
 import {
   IdeClient
-} from "./chunk-6TDA4EVC.js";
+} from "./chunk-JDPCOUZ3.js";
 import {
   createDebugLogger
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -27,7 +27,7 @@ import { execFile } from "node:child_process";
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "7c8e78069";
+var GIT_COMMIT_INFO = "24f4e5f25";
 
 // packages/cli/src/utils/systemInfo.ts
 var debugLogger = createDebugLogger("STATUS");

package/chunks/{chunk-3PE7OY2G.js → chunk-3QR5MOHP.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-OWAK7LMW.js";
 import {
   resolveBundleDir
-} from "./chunk-6TDA4EVC.js";
+} from "./chunk-JDPCOUZ3.js";
 import {
   Storage
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-4AGBO6RB.js → chunk-3SNKL6L6.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   HistoryReplayer
-} from "./chunk-WACI4VES.js";
+} from "./chunk-SG2PEESS.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
 import {
   getResponseText
-} from "./chunk-6TDA4EVC.js";
+} from "./chunk-JDPCOUZ3.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -312,6 +312,11 @@ function isPendingReplayToolCall(value) {
   return typeof value["callId"] === "string" && typeof value["toolName"] === "string" && (value["timestamp"] === void 0 || typeof value["timestamp"] === "string") && typeof value["recordId"] === "string";
 }
 __name(isPendingReplayToolCall, "isPendingReplayToolCall");
+function isCurrentPendingReplayToolCall(value) {
+  if (!isObjectRecord(value)) return false;
+  return typeof value["callId"] === "string" && typeof value["toolName"] === "string" && typeof value["sourceRecordId"] === "string" && (value["sourceTimestamp"] === void 0 || typeof value["sourceTimestamp"] === "string");
+}
+__name(isCurrentPendingReplayToolCall, "isCurrentPendingReplayToolCall");
 function parseTranscriptReplayState(replay, logger) {
   if (!isObjectRecord(replay)) {
     return {
@@ -319,8 +324,24 @@ function parseTranscriptReplayState(replay, logger) {
       cumulativeUsage: createReplayCumulativeUsage()
     };
   }
+  if ("v" in replay && replay["v"] !== 1) {
+    throw new TypeError("Unsupported transcript replay state version.");
+  }
   const rawPending = replay["pendingToolCalls"];
-  const pendingToolCalls = Array.isArray(rawPending) ? rawPending.filter(isPendingReplayToolCall) : [];
+  const pendingToolCalls = Array.isArray(rawPending) ? rawPending.flatMap((pending) => {
+    if (isPendingReplayToolCall(pending)) return [pending];
+    if (isCurrentPendingReplayToolCall(pending)) {
+      return [
+        {
+          callId: pending.callId,
+          toolName: pending.toolName,
+          recordId: pending.sourceRecordId,
+          ...pending.sourceTimestamp ? { timestamp: pending.sourceTimestamp } : {}
+        }
+      ];
+    }
+    return [];
+  }) : [];
   if (logger && Array.isArray(rawPending) && pendingToolCalls.length !== rawPending.length) {
     const dropped = rawPending.length - pendingToolCalls.length;
     logger.warn(
@@ -404,15 +425,15 @@ async function replayTranscriptRecordPage({
   const replayer = new HistoryReplayer(
     replayContext(sessionId, updates, state.cumulativeUsage, config)
   );
-  let pendingToolCalls;
+  let replayState;
   let replayError;
   try {
-    const replayState = await replayer.replayPage(page.records, {
+    const replayPageState = await replayer.replayPage(page.records, {
       pendingToolCalls: page.direction === "backward" ? [] : state.pendingToolCalls,
       finalizeDangling: page.direction === "backward" || !page.hasMore,
       gaps: page.gaps
     });
-    pendingToolCalls = replayState.pendingToolCalls;
+    replayState = replayPageState.replay;
   } catch (error) {
     logger?.warn(
       "[historyReplay] Paged history replay failed for session %s (partial updates: %d):",
@@ -420,17 +441,12 @@ async function replayTranscriptRecordPage({
       updates.length,
       error
     );
-    pendingToolCalls = replayer.getPendingToolCalls();
+    replayState = replayer.getReplayState();
     replayError = "Replay conversion failed for this page";
   }
   const nextCursor = page.nextCursorState && replayError === void 0 ? encodeCursor({
     ...page.nextCursorState,
-    ...page.direction === "backward" ? {} : {
-      replay: {
-        pendingToolCalls,
-        cumulativeUsage: state.cumulativeUsage
-      }
-    }
+    ...page.direction === "backward" ? {} : { replay: replayState }
   }) : void 0;
   return {
     updates: liftSessionUpdateTimestamps(updates),