@qwen-code/qwen-code 0.19.9 → 0.19.10-nightly.20260716.506ce0a1a

package/chunks/{chunk-GZRTYZ2R.js → chunk-H3XMJV7T.js}

@@ -1,8 +1,14 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  HistoryReplayer
+} from "./chunk-5DEJ4T6C.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
+import {
+  getResponseText
+} from "./chunk-SA6QVLWI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -274,6 +280,210 @@ function isValidServerName(name) {
 }
 __name(isValidServerName, "isValidServerName");
 
+// packages/cli/src/acp-integration/session/history-replay-page.ts
+init_esbuild_shims();
+function createReplayCumulativeUsage() {
+  return {
+    promptTokens: 0,
+    cachedTokens: 0,
+    candidateTokens: 0,
+    apiTimeMs: 0
+  };
+}
+__name(createReplayCumulativeUsage, "createReplayCumulativeUsage");
+function copyCumulativeUsage(target, source) {
+  target.promptTokens = source.promptTokens;
+  target.cachedTokens = source.cachedTokens;
+  target.candidateTokens = source.candidateTokens;
+  target.apiTimeMs = source.apiTimeMs;
+}
+__name(copyCumulativeUsage, "copyCumulativeUsage");
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObjectRecord, "isObjectRecord");
+function isCumulativeUsage(value) {
+  if (!isObjectRecord(value)) return false;
+  return typeof value["promptTokens"] === "number" && Number.isFinite(value["promptTokens"]) && typeof value["cachedTokens"] === "number" && Number.isFinite(value["cachedTokens"]) && typeof value["candidateTokens"] === "number" && Number.isFinite(value["candidateTokens"]) && typeof value["apiTimeMs"] === "number" && Number.isFinite(value["apiTimeMs"]);
+}
+__name(isCumulativeUsage, "isCumulativeUsage");
+function isPendingReplayToolCall(value) {
+  if (!isObjectRecord(value)) return false;
+  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 parseTranscriptReplayState(replay, logger) {
+  if (!isObjectRecord(replay)) {
+    return {
+      pendingToolCalls: [],
+      cumulativeUsage: createReplayCumulativeUsage()
+    };
+  }
+  const rawPending = replay["pendingToolCalls"];
+  const pendingToolCalls = Array.isArray(rawPending) ? rawPending.filter(isPendingReplayToolCall) : [];
+  if (logger && Array.isArray(rawPending) && pendingToolCalls.length !== rawPending.length) {
+    const dropped = rawPending.length - pendingToolCalls.length;
+    logger.warn(
+      `[transcript] replay state dropped ${dropped} of ${rawPending.length} malformed pending tool calls`
+    );
+  }
+  const cumulativeUsage = isCumulativeUsage(replay["cumulativeUsage"]) ? { ...replay["cumulativeUsage"] } : createReplayCumulativeUsage();
+  return { pendingToolCalls, cumulativeUsage };
+}
+__name(parseTranscriptReplayState, "parseTranscriptReplayState");
+function replayContext(sessionId, updates, cumulativeUsage, config) {
+  return {
+    sessionId,
+    sendUpdate: /* @__PURE__ */ __name(async (update) => {
+      updates.push(update);
+    }, "sendUpdate"),
+    cumulativeUsage,
+    ...config ? { config } : {}
+  };
+}
+__name(replayContext, "replayContext");
+async function collectHistoryReplayUpdates({
+  sessionId,
+  config,
+  records,
+  gaps,
+  cumulativeUsage,
+  logger
+}) {
+  const updates = [];
+  try {
+    await new HistoryReplayer(
+      replayContext(sessionId, updates, cumulativeUsage, config)
+    ).replay(records, gaps);
+  } catch (error) {
+    const replayError = error instanceof Error ? error.message : String(error);
+    logger?.warn(
+      "[historyReplay] History replay failed for session %s (partial updates: %d):",
+      sessionId,
+      updates.length,
+      error
+    );
+    return { updates: liftSessionUpdateTimestamps(updates), replayError };
+  }
+  return { updates: liftSessionUpdateTimestamps(updates) };
+}
+__name(collectHistoryReplayUpdates, "collectHistoryReplayUpdates");
+function liftSessionUpdateTimestamps(updates) {
+  return updates.map((update) => {
+    const record = update;
+    const meta = record["_meta"];
+    const timestamp = isObjectRecord(meta) ? meta["timestamp"] : void 0;
+    return typeof timestamp === "number" || typeof timestamp === "string" ? { ...record, timestamp } : update;
+  });
+}
+__name(liftSessionUpdateTimestamps, "liftSessionUpdateTimestamps");
+async function replayTranscriptRecordPage({
+  sessionId,
+  page,
+  config,
+  encodeCursor,
+  logger
+}) {
+  const state = parseTranscriptReplayState(page.replay, logger);
+  const updates = [];
+  const replayer = new HistoryReplayer(
+    replayContext(sessionId, updates, state.cumulativeUsage, config)
+  );
+  let pendingToolCalls;
+  let replayError;
+  try {
+    const replayState = await replayer.replayPage(page.records, {
+      pendingToolCalls: state.pendingToolCalls,
+      finalizeDangling: !page.hasMore,
+      gaps: page.gaps
+    });
+    pendingToolCalls = replayState.pendingToolCalls;
+  } catch (error) {
+    logger?.warn(
+      "[historyReplay] Paged history replay failed for session %s (partial updates: %d):",
+      sessionId,
+      updates.length,
+      error
+    );
+    pendingToolCalls = replayer.getPendingToolCalls();
+    replayError = "Replay conversion failed for this page";
+  }
+  const nextCursor = page.nextCursorState && replayError === void 0 ? encodeCursor({
+    ...page.nextCursorState,
+    replay: {
+      pendingToolCalls,
+      cumulativeUsage: state.cumulativeUsage
+    }
+  }) : void 0;
+  return {
+    updates: liftSessionUpdateTimestamps(updates),
+    ...nextCursor ? { nextCursor } : {},
+    hasMore: replayError === void 0 && page.hasMore,
+    startTime: page.startTime,
+    lastUpdated: page.lastUpdated,
+    ...replayError ? { partial: true, replayError } : {}
+  };
+}
+__name(replayTranscriptRecordPage, "replayTranscriptRecordPage");
+
+// packages/cli/src/acp-integration/generation.ts
+init_esbuild_shims();
+var GENERATION_MAX_PROMPT_BYTES = 32 * 1024;
+var GENERATION_TIMEOUT_MS = 6e4;
+async function executeGeneration(config, requestId, prompt, signal, emit) {
+  const fastModel = config.getFastModel();
+  const mainModel = config.getModel();
+  const client = config.getBaseLlmClient();
+  let modelSource = fastModel ? "fast" : "main";
+  let resolved;
+  if (fastModel) {
+    try {
+      resolved = await client.resolveForModel(fastModel, { failClosed: true });
+    } catch {
+      modelSource = "main";
+    }
+  }
+  resolved ??= await client.resolveForModel(mainModel, { failClosed: true });
+  const { contentGenerator, model } = resolved;
+  await emit({ type: "started", model, modelSource });
+  const stream = await contentGenerator.generateContentStream(
+    {
+      model,
+      contents: [{ role: "user", parts: [{ text: prompt }] }],
+      config: {
+        abortSignal: signal,
+        tools: [],
+        thinkingConfig: { thinkingBudget: 0, includeThoughts: false },
+        temperature: 0.2
+      }
+    },
+    `generation:${requestId}`
+  );
+  let seq = 0;
+  let thinkingEmitted = false;
+  let usage;
+  for await (const chunk of stream) {
+    if (!thinkingEmitted && chunk.candidates?.some(
+      (candidate) => candidate.content?.parts?.some((part) => part.thought === true)
+    )) {
+      thinkingEmitted = true;
+      await emit({ type: "thinking" });
+    }
+    const text = getResponseText(chunk) ?? "";
+    if (text) {
+      await emit({ type: "delta", seq: seq++, text });
+    }
+    if (chunk.usageMetadata) usage = chunk.usageMetadata;
+  }
+  return {
+    model,
+    modelSource,
+    ...usage?.promptTokenCount !== void 0 ? { inputTokens: usage.promptTokenCount } : {},
+    ...usage?.candidatesTokenCount !== void 0 ? { outputTokens: usage.candidatesTokenCount } : {}
+  };
+}
+__name(executeGeneration, "executeGeneration");
+
 export {
   createWorkspaceMemoryExtractionErrorLogger,
   extractRememberErrorCode,
@@ -283,7 +493,14 @@ export {
   MAX_REMEMBER_CONTENT_BYTES,
   formatWorkspaceMemoryForgetSummary,
   formatWorkspaceMemoryDreamSummary,
-  isValidServerName
+  isValidServerName,
+  createReplayCumulativeUsage,
+  copyCumulativeUsage,
+  collectHistoryReplayUpdates,
+  replayTranscriptRecordPage,
+  GENERATION_MAX_PROMPT_BYTES,
+  GENERATION_TIMEOUT_MS,
+  executeGeneration
 };
 /**
  * @license