@qwen-code/qwen-code 0.22.2 → 0.22.3-nightly.20260829.e5cb60ad48

package/chunks/chunk-7J6OTNGO.js

@@ -0,0 +1,424 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/transcript-records.ts
+init_esbuild_shims();
+var USER_PROMPT_SUBMIT_CONTEXT_OPEN = "<qwen:user-prompt-submit-context>";
+var USER_PROMPT_SUBMIT_CONTEXT_CLOSE = "</qwen:user-prompt-submit-context>";
+var TranscriptRecordPreparationError = class extends TypeError {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "TranscriptRecordPreparationError";
+  }
+  static {
+    __name(this, "TranscriptRecordPreparationError");
+  }
+};
+var RECORD_TYPES = /* @__PURE__ */ new Set([
+  "user",
+  "assistant",
+  "tool_result",
+  "system"
+]);
+var ARTIFACT_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
+  "session_artifact_event",
+  "session_artifact_snapshot"
+]);
+var KNOWN_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
+  "chat_compression",
+  "slash_command",
+  "ui_telemetry",
+  "at_command",
+  "attribution_snapshot",
+  "notification",
+  "cron",
+  "mid_turn_user_message",
+  "realtime_message",
+  "custom_title",
+  "parent_session",
+  "rewind",
+  "agent_bootstrap",
+  "agent_launch_prompt",
+  "agent_retry",
+  "file_history_snapshot",
+  "session_source",
+  "session_model",
+  "branch_checkpoint",
+  "goal_state",
+  "goal_runtime",
+  "turn_result",
+  ...ARTIFACT_RECORD_SUBTYPES
+]);
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObjectRecord, "isObjectRecord");
+function wrapUserPromptSubmitContext(context) {
+  return `${USER_PROMPT_SUBMIT_CONTEXT_OPEN}
+${context}
+${USER_PROMPT_SUBMIT_CONTEXT_CLOSE}`;
+}
+__name(wrapUserPromptSubmitContext, "wrapUserPromptSubmitContext");
+function isUserPromptSubmitContextPartText(text) {
+  const trimmed = text.trim();
+  const prefix = `${USER_PROMPT_SUBMIT_CONTEXT_OPEN}
+`;
+  const suffix = `
+${USER_PROMPT_SUBMIT_CONTEXT_CLOSE}`;
+  if (!trimmed.startsWith(prefix) || !trimmed.endsWith(suffix)) {
+    return false;
+  }
+  const body = trimmed.slice(prefix.length, -suffix.length);
+  return !body.includes(USER_PROMPT_SUBMIT_CONTEXT_OPEN) && !body.includes(USER_PROMPT_SUBMIT_CONTEXT_CLOSE);
+}
+__name(isUserPromptSubmitContextPartText, "isUserPromptSubmitContextPartText");
+function isUserPromptSubmitContextPart(part) {
+  return isObjectRecord(part) && typeof part["text"] === "string" && isUserPromptSubmitContextPartText(part["text"]);
+}
+__name(isUserPromptSubmitContextPart, "isUserPromptSubmitContextPart");
+function projectUserTranscriptForDisplay(record) {
+  const parts = record.message?.parts ?? [];
+  const hasFinalHookContextPart = parts.length > 1 && isUserPromptSubmitContextPart(parts[parts.length - 1]);
+  const payload = isObjectRecord(record.systemPayload) ? record.systemPayload : void 0;
+  const isUserPromptPayload = payload && (typeof payload["hookContext"] === "string" || hasFinalHookContextPart);
+  const displayText = isUserPromptPayload && typeof payload["displayText"] === "string" ? payload["displayText"] : void 0;
+  if (displayText !== void 0) {
+    const visibleParts = parts.filter(
+      (part) => !isObjectRecord(part) || typeof part["text"] !== "string"
+    );
+    return { displayText, parts: visibleParts };
+  }
+  if (payload === void 0 && hasFinalHookContextPart) {
+    return { displayText: void 0, parts: parts.slice(0, -1) };
+  }
+  return { displayText: void 0, parts };
+}
+__name(projectUserTranscriptForDisplay, "projectUserTranscriptForDisplay");
+function diagnostic(code, message, affectsCompleteness, fields = {}, severity = affectsCompleteness ? "warning" : "info") {
+  return {
+    code,
+    severity,
+    message,
+    affectsCompleteness,
+    ...fields
+  };
+}
+__name(diagnostic, "diagnostic");
+function isTranscriptConversationRecord(record) {
+  return !isTranscriptArtifactRecord(record);
+}
+__name(isTranscriptConversationRecord, "isTranscriptConversationRecord");
+function isTranscriptArtifactRecord(record) {
+  return record.type === "system" && typeof record.subtype === "string" && ARTIFACT_RECORD_SUBTYPES.has(record.subtype);
+}
+__name(isTranscriptArtifactRecord, "isTranscriptArtifactRecord");
+function validateTranscriptRecord(value, recordIndex) {
+  const diagnostics = [];
+  if (!isObjectRecord(value)) {
+    diagnostics.push(
+      diagnostic(
+        "invalid_record",
+        "Skipped a transcript record that is not an object.",
+        true,
+        { recordIndex }
+      )
+    );
+    return { diagnostics };
+  }
+  const uuid = value["uuid"];
+  const parentUuid = value["parentUuid"];
+  const sessionId = value["sessionId"];
+  const type = value["type"];
+  const recordId = typeof uuid === "string" ? uuid : void 0;
+  if (typeof uuid !== "string" || uuid.length === 0 || typeof parentUuid !== "string" && parentUuid !== null || typeof sessionId !== "string" || sessionId.length === 0) {
+    diagnostics.push(
+      diagnostic(
+        "invalid_record",
+        "Skipped a transcript record with invalid identity fields.",
+        true,
+        { recordIndex, recordId }
+      )
+    );
+    return { diagnostics };
+  }
+  if (typeof type !== "string" || !RECORD_TYPES.has(type)) {
+    diagnostics.push(
+      diagnostic(
+        "unknown_record_or_part",
+        "Skipped a transcript record with an unknown record type.",
+        true,
+        { recordIndex, recordId }
+      )
+    );
+    return { diagnostics };
+  }
+  const timestamp = value["timestamp"];
+  if (timestamp !== void 0 && (typeof timestamp !== "string" || !Number.isFinite(new Date(timestamp).getTime()))) {
+    diagnostics.push(
+      diagnostic(
+        "invalid_timestamp",
+        "Ignored an invalid transcript record timestamp.",
+        false,
+        { recordIndex, recordId, path: "timestamp" }
+      )
+    );
+  }
+  const subtype = value["subtype"];
+  if (subtype !== void 0 && (typeof subtype !== "string" || !KNOWN_RECORD_SUBTYPES.has(subtype))) {
+    diagnostics.push(
+      diagnostic(
+        "unknown_record_or_part",
+        "The transcript record has an unknown subtype.",
+        true,
+        { recordIndex, recordId, path: "subtype" }
+      )
+    );
+  }
+  let message;
+  if (value["message"] !== void 0) {
+    if (!isObjectRecord(value["message"])) {
+      diagnostics.push(
+        diagnostic(
+          "malformed_part",
+          "Ignored a malformed transcript message payload.",
+          true,
+          { recordIndex, recordId, path: "message" }
+        )
+      );
+    } else {
+      const parts = value["message"]["parts"];
+      if (parts !== void 0 && !Array.isArray(parts)) {
+        diagnostics.push(
+          diagnostic(
+            "malformed_part",
+            "Ignored malformed transcript message parts.",
+            true,
+            { recordIndex, recordId, path: "message.parts" }
+          )
+        );
+      }
+      message = {
+        ...typeof value["message"]["role"] === "string" ? { role: value["message"]["role"] } : {},
+        ...Array.isArray(parts) ? { parts } : {}
+      };
+    }
+  }
+  return {
+    record: {
+      ...value,
+      uuid,
+      parentUuid,
+      sessionId,
+      type,
+      ...typeof subtype === "string" ? { subtype } : { subtype: void 0 },
+      ...typeof timestamp === "string" && Number.isFinite(new Date(timestamp).getTime()) ? { timestamp } : { timestamp: void 0 },
+      ...message ? { message } : { message: void 0 }
+    },
+    diagnostics
+  };
+}
+__name(validateTranscriptRecord, "validateTranscriptRecord");
+function selectTranscriptLeaf(records, leafUuid) {
+  if (leafUuid !== void 0) {
+    return records.some(
+      (record) => record.uuid === leafUuid && isTranscriptConversationRecord(record)
+    ) ? leafUuid : void 0;
+  }
+  for (let index = records.length - 1; index >= 0; index -= 1) {
+    const record = records[index];
+    if (record && isTranscriptConversationRecord(record)) return record.uuid;
+  }
+  return void 0;
+}
+__name(selectTranscriptLeaf, "selectTranscriptLeaf");
+function walkTranscriptUuidChain(leafUuid, lookup) {
+  const uuids = [];
+  const gaps = [];
+  const visited = /* @__PURE__ */ new Set();
+  let currentUuid = leafUuid;
+  let cycleUuid;
+  while (currentUuid) {
+    if (visited.has(currentUuid)) {
+      cycleUuid = currentUuid;
+      break;
+    }
+    visited.add(currentUuid);
+    const record = lookup(currentUuid);
+    if (!record) break;
+    uuids.push(currentUuid);
+    if (!record.parentUuid) break;
+    if (!lookup(record.parentUuid)) {
+      gaps.push({
+        childUuid: currentUuid,
+        missingParentUuid: record.parentUuid
+      });
+      break;
+    }
+    currentUuid = record.parentUuid;
+  }
+  uuids.reverse();
+  return { uuids, gaps, ...cycleUuid ? { cycleUuid } : {} };
+}
+__name(walkTranscriptUuidChain, "walkTranscriptUuidChain");
+function aggregateTranscriptRecordFragments(records) {
+  const first = records[0];
+  if (!first) {
+    throw new Error("Cannot aggregate empty transcript record array");
+  }
+  const base = { ...first };
+  let message = first.message ? { ...first.message, parts: [...first.message.parts ?? []] } : void 0;
+  for (let index = 1; index < records.length; index += 1) {
+    const record = records[index];
+    if (record.message !== void 0) {
+      message = message ? {
+        role: message.role,
+        parts: [...message.parts ?? [], ...record.message.parts ?? []]
+      } : { ...record.message, parts: [...record.message.parts ?? []] };
+    }
+    if (record.usageMetadata) base["usageMetadata"] = record.usageMetadata;
+    if (record.toolCallResult && !base["toolCallResult"]) {
+      base["toolCallResult"] = record.toolCallResult;
+    }
+    if (record.model && !base["model"]) base["model"] = record.model;
+    if (record.timestamp && (!base["timestamp"] || record.timestamp > String(base["timestamp"]))) {
+      base["timestamp"] = record.timestamp;
+    }
+  }
+  base["message"] = message;
+  return base;
+}
+__name(aggregateTranscriptRecordFragments, "aggregateTranscriptRecordFragments");
+function prepareTranscriptRecords(values, options = {}) {
+  if (!Array.isArray(values)) {
+    throw new TranscriptRecordPreparationError(
+      "invalid_records",
+      "Transcript records must be an array."
+    );
+  }
+  const diagnostics = [];
+  const records = [];
+  const sourceIndexByRecord = /* @__PURE__ */ new Map();
+  for (let index = 0; index < values.length; index += 1) {
+    const validated = validateTranscriptRecord(values[index], index);
+    diagnostics.push(...validated.diagnostics);
+    if (validated.record) {
+      records.push(validated.record);
+      sourceIndexByRecord.set(validated.record, index);
+    }
+  }
+  const sessionIds = new Set(records.map((record) => record.sessionId));
+  if (sessionIds.size > 1) {
+    throw new TranscriptRecordPreparationError(
+      "mixed_session_ids",
+      "Transcript records contain multiple session ids."
+    );
+  }
+  const leafUuid = selectTranscriptLeaf(records, options.leafUuid);
+  if (options.leafUuid !== void 0 && leafUuid === void 0) {
+    throw new TranscriptRecordPreparationError(
+      "leaf_not_found",
+      "The requested transcript leaf was not found."
+    );
+  }
+  if (!leafUuid) {
+    if (records.length > 0) {
+      diagnostics.push(
+        diagnostic(
+          "artifact_only",
+          "The input contains no conversation records.",
+          false
+        )
+      );
+    }
+    return {
+      ...sessionIds.size === 1 ? { sessionId: records[0].sessionId } : {},
+      records: [],
+      gaps: [],
+      diagnostics
+    };
+  }
+  const fragmentsByUuid = /* @__PURE__ */ new Map();
+  const firstByUuid = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    if (!isTranscriptConversationRecord(record)) continue;
+    const fragments = fragmentsByUuid.get(record.uuid);
+    if (fragments) {
+      if (fragments[0].parentUuid !== record.parentUuid) {
+        diagnostics.push(
+          diagnostic(
+            "conflicting_parent_uuid",
+            "Duplicate transcript record fragments disagree on parentUuid.",
+            true,
+            {
+              recordIndex: sourceIndexByRecord.get(record),
+              recordId: record.uuid,
+              path: "parentUuid"
+            }
+          )
+        );
+      }
+      fragments.push(record);
+    } else {
+      fragmentsByUuid.set(record.uuid, [record]);
+      firstByUuid.set(record.uuid, record);
+    }
+  }
+  const chain = walkTranscriptUuidChain(
+    leafUuid,
+    (uuid) => firstByUuid.get(uuid)
+  );
+  for (const gap of chain.gaps) {
+    diagnostics.push(
+      diagnostic(
+        "history_gap",
+        "The active transcript chain is missing a parent record.",
+        true,
+        { recordId: gap.childUuid }
+      )
+    );
+  }
+  if (chain.cycleUuid) {
+    diagnostics.push(
+      diagnostic(
+        "parent_cycle",
+        "The active transcript chain contains a parent cycle.",
+        true,
+        { recordId: chain.cycleUuid }
+      )
+    );
+  }
+  return {
+    ...sessionIds.size === 1 ? { sessionId: records[0].sessionId } : {},
+    records: chain.uuids.map(
+      (uuid) => aggregateTranscriptRecordFragments(fragmentsByUuid.get(uuid) ?? [])
+    ),
+    gaps: chain.gaps,
+    diagnostics
+  };
+}
+__name(prepareTranscriptRecords, "prepareTranscriptRecords");
+
+export {
+  wrapUserPromptSubmitContext,
+  isUserPromptSubmitContextPartText,
+  projectUserTranscriptForDisplay,
+  isTranscriptConversationRecord,
+  isTranscriptArtifactRecord,
+  validateTranscriptRecord,
+  selectTranscriptLeaf,
+  walkTranscriptUuidChain,
+  aggregateTranscriptRecordFragments,
+  prepareTranscriptRecords
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-DIMEPKCW.js → chunk-7S226YTK.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-AYHQZBJ4.js";
 import {
   writeStderrLine
-} from "./chunk-KGJGEEVR.js";
+} from "./chunk-7FA2II6K.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-XRSOI3DL.js → chunk-A3LWD5MK.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-LDP5OD6N.js";
+} from "./chunk-CLWO3B77.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-FBSSIAAQ.js → chunk-AMLXTTJJ.js}

@@ -2,30 +2,30 @@
 "use strict";
 import {
   getExtensionManager
-} from "./chunk-PFCQ62V4.js";
+} from "./chunk-JWDMKJG5.js";
 import {
   parseChannelConfig
-} from "./chunk-HVQ3B7FF.js";
+} from "./chunk-Y5S7LBOZ.js";
 import {
   getPlugin,
   registerPlugin
-} from "./chunk-5XBFCMWD.js";
+} from "./chunk-3XKLXHGK.js";
 import {
   sanitizeLogText
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-ICURCKIU.js";
 import {
   loadSettings
-} from "./chunk-F7TNAPZ4.js";
+} from "./chunk-5SBVOOA2.js";
 import {
   hashDaemonWorkspace
-} from "./chunk-HVEYF6VT.js";
+} from "./chunk-3WK3QDNV.js";
 import {
   Storage
 } from "./chunk-UHQFIS7N.js";
 import {
   writeStderrLine,
   writeStdoutLine
-} from "./chunk-KGJGEEVR.js";
+} from "./chunk-7FA2II6K.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-Z7FLBQPR.js → chunk-ARF6IJHM.js}

@@ -410,18 +410,18 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   try {
     if (authType === "openai" /* USE_OPENAI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-SUCYANUZ.js");
+        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-AGTNYSCJ.js");
         return createOpenAIContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-RF33DNZW.js");
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-OF5WRBQT.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
           isInitialAuth ? { requireCachedCredentials: true } : void 0
         );
         loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-          const { QwenContentGenerator } = await import("./qwenContentGenerator-J4TXFGJT.js");
+          const { QwenContentGenerator } = await import("./qwenContentGenerator-NU6PCDA7.js");
           return new QwenContentGenerator(qwenClient, generatorConfig, config);
         }, "loadBaseGenerator");
       } catch (error) {
@@ -432,13 +432,13 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       }
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-HGMBACVE.js");
+        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-YVTB6QX7.js");
         return createAnthropicContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createGeminiContentGenerator } = await import("./geminiContentGenerator-PUNEBWJW.js");
-        return createGeminiContentGenerator(generatorConfig, config);
+        const { createLlmContentGenerator } = await import("./llm-content-generator-Q7JJDSJR.js");
+        return createLlmContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else {
       throw new Error(
@@ -452,7 +452,7 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
     try {
       const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
         loadBaseGenerator(),
-        import("./loggingContentGenerator-2GGZNGLG.js")
+        import("./loggingContentGenerator-SBCIJG2J.js")
       ]);
       return new LoggingContentGenerator(
         baseGenerator,

package/chunks/{chunk-4CDSK5AZ.js → chunk-AYFA7MZV.js}

@@ -5,11 +5,11 @@ import {
 } from "./chunk-XQFT3QUF.js";
 import {
   runRipgrep
-} from "./chunk-43GGFFLY.js";
+} from "./chunk-4K7KNVWH.js";
 import {
   RipgrepRuntimeRecoveryEvent,
   logRipgrepRuntimeRecovery
-} from "./chunk-L2M46FP5.js";
+} from "./chunk-QYMAKPY5.js";
 import {
   DEFAULT_FILE_FILTERING_OPTIONS,
   QwenIgnoreParser,

package/chunks/{chunk-4JWNNLPT.js → chunk-B42A5ZHA.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   performStandaloneUpdate
-} from "./chunk-QP4C6WCE.js";
+} from "./chunk-PI6HYGBE.js";
 import {
   updateEventEmitter
 } from "./chunk-YAF2MQZ6.js";
@@ -11,12 +11,12 @@ import {
 } from "./chunk-2AUM35J5.js";
 import {
   t
-} from "./chunk-LDP5OD6N.js";
+} from "./chunk-CLWO3B77.js";
 import {
   getHomebrewLatestVersion,
   getInstallationInfo,
   resolveUpdateCommand
-} from "./chunk-V2NDP3I4.js";
+} from "./chunk-2AEHQRY2.js";
 import {
   createDebugLogger
 } from "./chunk-UHQFIS7N.js";

package/chunks/{chunk-3JGZSIDA.js → chunk-B466ZSHZ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   delay
-} from "./chunk-VVW4ZNFY.js";
+} from "./chunk-4QHPPXK2.js";
 import {
   isTlsVerificationDisabled
 } from "./chunk-PPKZ7JOE.js";