@qwen-code/qwen-code 0.22.2 → 0.22.3

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-O2UN57NX.js → chunk-7LOELM2I.js}

@@ -1,13 +1,16 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  multiSessionCompatibilityError
+} from "./chunk-Y5S7LBOZ.js";
 import {
   UNSAFE_OBJECT_KEYS,
   getPlugin
-} from "./chunk-5XBFCMWD.js";
+} from "./chunk-3XKLXHGK.js";
 import {
   loadSettings,
   saveSettings
-} from "./chunk-F7TNAPZ4.js";
+} from "./chunk-AIAOIFY4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -105,6 +108,12 @@ function assertNumberRecord(key, value, allowedKeys) {
 }
 __name(assertNumberRecord, "assertNumberRecord");
 function assertSharedField(key, value, previous) {
+  if (key === "multiSession") {
+    if (typeof value !== "boolean") {
+      throw invalidConfig(`Channel field "${key}" must be a boolean.`);
+    }
+    return true;
+  }
   const enumValues = {
     senderPolicy: /* @__PURE__ */ new Set(["allowlist", "pairing", "open"]),
     dmPolicy: /* @__PURE__ */ new Set(["open", "disabled"]),
@@ -398,6 +407,14 @@ var WorkspaceChannelSettingsStore = class {
       if (value !== void 0) nextConfig[key] = value;
     }
     assertManagedConfig(nextConfig, previous, plugin.management.fields);
+    const multiSessionError = multiSessionCompatibilityError(name, {
+      multiSession: nextConfig["multiSession"] === true,
+      sessionScope: nextConfig["sessionScope"] ?? plugin.defaultSessionScope ?? "user",
+      groupHistoryLimit: nextConfig["groupHistoryLimit"],
+      groups: isRecord(nextConfig["groups"]) ? nextConfig["groups"] : {},
+      webhooks: nextConfig["webhooks"]
+    });
+    if (multiSessionError) throw invalidConfig(multiSessionError);
     let crossFieldError;
     try {
       crossFieldError = plugin.management.validateConfig?.(nextConfig);

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-CPGJJJLU.js → chunk-7T52W4SW.js}

@@ -6,7 +6,7 @@ import {
   getNestedProperty,
   getPersistScopeForModelSelection,
   restoreSettingsFromBackup
-} from "./chunk-F7TNAPZ4.js";
+} from "./chunk-AIAOIFY4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-5O72BNDD.js → chunk-7VMIMAVB.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   loadSettings
-} from "./chunk-F7TNAPZ4.js";
+} from "./chunk-AIAOIFY4.js";
 import {
   getCurrentLanguage
-} from "./chunk-LDP5OD6N.js";
+} from "./chunk-CLWO3B77.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-V4QXXQJ2.js";
+} from "./chunk-MF7HCQWZ.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
 import {
   hashMcpServerConfig
-} from "./chunk-KUX5D6DK.js";
+} from "./chunk-NV55WWD6.js";
 import {
   Config,
   ExtensionManager,
@@ -25,11 +25,11 @@ import {
   isGatedMcpScope,
   normalizeClaudeMcpServer,
   runWithTimeout
-} from "./chunk-TGWAQ5RB.js";
+} from "./chunk-PZ66FRIC.js";
 import {
   getMCPServerLastError,
   getMCPServerStatus
-} from "./chunk-L2M46FP5.js";
+} from "./chunk-QYMAKPY5.js";
 import {
   atomicWriteFile
 } from "./chunk-23RFD54N.js";
@@ -40,7 +40,7 @@ import {
 import {
   writeStderrLine,
   writeStdoutLine
-} 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-F7TNAPZ4.js → chunk-AIAOIFY4.js}

@@ -7,7 +7,7 @@ import {
 import {
   customDeepMerge,
   getSettingsSchema
-} from "./chunk-JSC3H3TD.js";
+} from "./chunk-ZEYFMJQA.js";
 import {
   CONSOLIDATED_DISABLE_KEYS,
   V1_INDICATOR_KEYS,
@@ -22,7 +22,7 @@ import {
 } from "./chunk-IDS7MSUP.js";
 import {
   t
-} from "./chunk-LDP5OD6N.js";
+} from "./chunk-CLWO3B77.js";
 import {
   SUPPORTED_LANGUAGES,
   getLanguageNameFromLocale
@@ -31,15 +31,15 @@ import {
   getHomeEnvFallbackVars,
   loadEnvironment,
   preResolveHomeEnvOverrides
-} from "./chunk-IK5BW3CS.js";
+} from "./chunk-XHF7WQ6B.js";
 import {
   ENV_CORRUPTED_PATH,
   ENV_WAS_RECOVERED
-} from "./chunk-5PA6UEYA.js";
+} from "./chunk-MZCJWS5Y.js";
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-V4QXXQJ2.js";
+} from "./chunk-MF7HCQWZ.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";

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-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";