@qwen-code/qwen-code 0.23.2 → 0.23.3-nightly.20260910.c46cb85cf2

package/chunks/chunk-CF5KXZZX.js

@@ -0,0 +1,150 @@
+// 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/schemaConverter.ts
+init_esbuild_shims();
+function convertSchema(schema, mode = "auto") {
+  if (mode === "openapi_30") {
+    return toOpenAPI30(schema);
+  }
+  return schema;
+}
+__name(convertSchema, "convertSchema");
+function toOpenAPI30(schema) {
+  const convert = /* @__PURE__ */ __name((obj) => {
+    if (typeof obj !== "object" || obj === null) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map(convert);
+    }
+    const source = obj;
+    const target = {};
+    if (Array.isArray(source["type"])) {
+      const types = source["type"];
+      if (types.length === 2 && types.includes("null")) {
+        target["type"] = types.find((t) => t !== "null");
+        target["nullable"] = true;
+      } else {
+        target["type"] = types.find((t) => t !== "null") ?? types[0];
+        if (types.includes("null")) {
+          target["nullable"] = true;
+        }
+      }
+    } else if (source["type"] !== void 0) {
+      target["type"] = source["type"];
+    }
+    if (source["const"] !== void 0) {
+      target["enum"] = [String(source["const"])];
+      delete target["const"];
+    }
+    if (typeof source["exclusiveMinimum"] === "number") {
+      target["minimum"] = source["exclusiveMinimum"];
+      target["exclusiveMinimum"] = true;
+    }
+    if (typeof source["exclusiveMaximum"] === "number") {
+      target["maximum"] = source["exclusiveMaximum"];
+      target["exclusiveMaximum"] = true;
+    }
+    if (Array.isArray(source["items"])) {
+      delete target["items"];
+    } else if (typeof source["items"] === "object" && source["items"] !== null) {
+      target["items"] = convert(source["items"]);
+    }
+    if (Array.isArray(source["enum"])) {
+      target["enum"] = source["enum"].map(String);
+    }
+    for (const [key, value] of Object.entries(source)) {
+      if ((key === "properties" || key === "$defs" || key === "definitions") && typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const map = {};
+        for (const [mapKey, mapValue] of Object.entries(
+          value
+        )) {
+          map[mapKey] = convert(mapValue);
+        }
+        target[key] = map;
+        continue;
+      }
+      if (key === "type" || key === "const" || key === "items" || key === "enum" || key === "$schema" || key === "$id" || key === "default" || // Optional: Gemini sometimes complains about defaults conflicting with types
+      key === "dependencies" || key === "patternProperties") {
+        continue;
+      }
+      if ((key === "exclusiveMinimum" || key === "exclusiveMaximum") && typeof value === "number") {
+        continue;
+      }
+      target[key] = convert(value);
+    }
+    return target;
+  }, "convert");
+  return convert(schema);
+}
+__name(toOpenAPI30, "toOpenAPI30");
+function relaxSchemaForFunctionCalling(schema, relaxGrammarConstraints = false) {
+  const relax = /* @__PURE__ */ __name((obj) => {
+    if (typeof obj !== "object" || obj === null) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map(relax);
+    }
+    const source = obj;
+    const target = {};
+    const properties = source["properties"];
+    const required = Array.isArray(source["required"]) ? source["required"].filter(
+      (r) => typeof r === "string"
+    ) : [];
+    const hasOptionalProperties = typeof properties === "object" && properties !== null && !Array.isArray(properties) && Object.keys(properties).some((key) => !required.includes(key));
+    const hasEmptyProperties = typeof properties === "object" && properties !== null && !Array.isArray(properties) && Object.keys(properties).length === 0;
+    const type = source["type"];
+    const canBeObject = type === void 0 || type === "object" || Array.isArray(type) && type.includes("object");
+    const hasNoDeclaredProperties = hasEmptyProperties || canBeObject && properties === void 0;
+    for (const [key, value] of Object.entries(source)) {
+      if (key === "$schema" || key === "$id" || key === "uniqueItems") {
+        continue;
+      }
+      if (relaxGrammarConstraints && key === "properties" && hasEmptyProperties) {
+        continue;
+      }
+      if (relaxGrammarConstraints && (key === "minLength" || key === "maxLength" || key === "minItems" || key === "maxItems") && typeof value === "number" && value >= 1999) {
+        continue;
+      }
+      if (key === "additionalProperties" && value === false && (hasOptionalProperties || relaxGrammarConstraints && hasNoDeclaredProperties)) {
+        continue;
+      }
+      if (key === "const" || key === "default" || key === "enum" || key === "example" || key === "examples") {
+        target[key] = structuredClone(value);
+        continue;
+      }
+      if ((key === "properties" || key === "patternProperties" || key === "$defs" || key === "definitions" || key === "dependencies" || key === "dependentSchemas" || key === "dependentRequired") && typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const map = {};
+        for (const [mapKey, mapValue] of Object.entries(
+          value
+        )) {
+          map[mapKey] = relax(mapValue);
+        }
+        target[key] = map;
+        continue;
+      }
+      target[key] = relax(value);
+    }
+    return target;
+  }, "relax");
+  return relax(schema);
+}
+__name(relaxSchemaForFunctionCalling, "relaxSchemaForFunctionCalling");
+
+export {
+  convertSchema,
+  relaxSchemaForFunctionCalling
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-SOA4HKRJ.js → chunk-CGKEUUYG.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   isPrivateHost
-} from "./chunk-OFVAS4AR.js";
+} from "./chunk-ZGQIIGNQ.js";
 import {
   loadUndici
-} from "./chunk-4HOEU2OR.js";
+} from "./chunk-EWJTAP3Y.js";
 import {
   getErrorMessage
 } from "./chunk-ZAFYHRVY.js";

package/chunks/{chunk-TGNNLRC3.js → chunk-CJ3DHN5I.js}

@@ -18,6 +18,7 @@ export {
   CHANNEL_WORKER_STARTUP_TIMEOUT_MS,
   CHANNEL_WORKER_STOP_GRACE_MS,
   CHANNEL_WORKER_KILL_GRACE_MS,
+  MAX_CHANNEL_CONTROL_WORKSPACES,
   CHANNEL_CONTROL_DEFAULT_TIMEOUT_MS
 };
 /**

package/chunks/{chunk-AUTUFD5X.js → chunk-CSHX5ZC4.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolvePath
-} from "./chunk-WDVV3LRM.js";
+} from "./chunk-C4NLHK7X.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-UYDQYDW2.js → chunk-CUK6F5UF.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   wrapForMultiplexer
-} from "./chunk-XDNFODER.js";
+} from "./chunk-B6BDT4RX.js";
 import {
   createDebugLogger
 } from "./chunk-ZAFYHRVY.js";

package/chunks/{chunk-CALTQWTZ.js → chunk-DLH7YIX6.js}

@@ -6,7 +6,7 @@ import {
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-QAZ2MGYT.js";
+} from "./chunk-PLLIWEM3.js";
 import {
   resolveActiveTeamName
 } from "./chunk-S6LOFUVP.js";
@@ -15,7 +15,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MWIO7MF6.js";
+} from "./chunk-TP6FYVQT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-CMWU6P4D.js → chunk-DMX7RF6E.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   registerCleanup
-} from "./chunk-DAI65CMX.js";
+} from "./chunk-JDEW3V5B.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-TRWQQBVH.js → chunk-DTNV6UZY.js}

@@ -3,7 +3,7 @@
 import {
   execCommand,
   isCommandAvailable
-} from "./chunk-N6S3NUYJ.js";
+} from "./chunk-JXNIF2O5.js";
 import {
   fileExists
 } from "./chunk-J6MB5ZHZ.js";

package/chunks/{chunk-GSFV5RQW.js → chunk-E4UEO3XM.js}

@@ -51,6 +51,7 @@ var KNOWN_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
   "file_history_snapshot",
   "session_source",
   "session_model",
+  "session_sources_snapshot",
   "branch_checkpoint",
   "goal_state",
   "goal_runtime",
@@ -132,7 +133,7 @@ function diagnostic(code, message, affectsCompleteness, fields = {}, severity =
 }
 __name(diagnostic, "diagnostic");
 function isTranscriptConversationRecord(record) {
-  return !isTranscriptArtifactRecord(record);
+  return !isTranscriptArtifactRecord(record) && !(record.type === "system" && record.subtype === "session_sources_snapshot");
 }
 __name(isTranscriptConversationRecord, "isTranscriptConversationRecord");
 function isTranscriptArtifactRecord(record) {
@@ -471,7 +472,7 @@ function selectActiveSideArtifactRecordUuids(records, activeRecordUuids) {
     if (activeUuids.has(record.uuid)) {
       nextActiveUuid = record.uuid;
       nextBlockingUuid = void 0;
-    } else if (!isSessionArtifactRecord(record) && !(record.type === "system" && record.subtype === "custom_title")) {
+    } else if (!isSessionArtifactRecord(record) && !(record.type === "system" && (record.subtype === "custom_title" || record.subtype === "session_sources_snapshot"))) {
       nextBlockingUuid = record.uuid;
     }
   }

package/chunks/{chunk-KFECPHLV.js → chunk-E5GQNSJY.js}

@@ -3,7 +3,7 @@
 import {
   getUserSettingsPath,
   v1ToV2Migration
-} from "./chunk-WBU2PIZ5.js";
+} from "./chunk-OOLSYRZ7.js";
 import {
   getSystemDefaultsPath,
   getSystemSettingsPath
@@ -13,7 +13,7 @@ import {
   TrustLevel,
   getExplicitTrustLevel,
   getTrustedFoldersPath
-} from "./chunk-NX7ZTXFF.js";
+} from "./chunk-KHIBLKNK.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-MR3PXB6E.js";
 import {
   ideContextStore
-} from "./chunk-HJ5UJQQL.js";
+} from "./chunk-JV5YASQA.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-ELRMZTPF.js

@@ -0,0 +1,374 @@
+// 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/services/session-sources.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import path from "node:path";
+var SessionSourceError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SessionSourceError";
+  }
+  static {
+    __name(this, "SessionSourceError");
+  }
+};
+var invalid = /* @__PURE__ */ __name((message) => {
+  throw new SessionSourceError("invalid_source", message);
+}, "invalid");
+function object(value, fields) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return invalid("Source must be an object");
+  }
+  if (Object.keys(value).some((key) => !fields.includes(key))) {
+    return invalid("Unknown source field");
+  }
+  return value;
+}
+__name(object, "object");
+function text(value, field, limit, empty = false, trim = true) {
+  if (typeof value !== "string" || /[\p{Cc}\p{Cf}]/u.test(value)) {
+    return invalid(`Invalid ${field}`);
+  }
+  const normalized = trim ? value.trim() : value;
+  if (!empty && !normalized || normalized.length > limit) {
+    return invalid(`Invalid ${field} length (maximum ${limit})`);
+  }
+  return normalized;
+}
+__name(text, "text");
+function validateSessionSourceInput(value) {
+  const input = object(value, ["title", "description", "locator"]);
+  const title = text(input["title"], "title", 200);
+  const description = input["description"] === void 0 ? void 0 : text(input["description"], "description", 1e3, true);
+  const raw = object(input["locator"], [
+    "type",
+    "workspacePath",
+    "attachmentId",
+    "url"
+  ]);
+  let locator;
+  switch (raw["type"]) {
+    case "workspace_file": {
+      object(raw, ["type", "workspacePath"]);
+      const sourcePath = text(
+        raw["workspacePath"],
+        "workspacePath",
+        500,
+        false,
+        false
+      ).replaceAll("\\", "/");
+      if (sourcePath.startsWith("/") || /^[a-z]:/iu.test(sourcePath)) {
+        return invalid("Workspace path must be relative");
+      }
+      const segments = [];
+      for (const segment of sourcePath.split("/")) {
+        if (!segment || segment === ".") continue;
+        if (segment === "..") {
+          if (!segments.length)
+            return invalid("Workspace path escapes its root");
+          segments.pop();
+        } else {
+          segments.push(segment);
+        }
+      }
+      if (!segments.length)
+        return invalid("Workspace path must identify a file");
+      locator = { type: "workspace_file", workspacePath: segments.join("/") };
+      break;
+    }
+    case "attachment":
+      object(raw, ["type", "attachmentId"]);
+      locator = {
+        type: "attachment",
+        attachmentId: text(
+          raw["attachmentId"],
+          "attachmentId",
+          200,
+          false,
+          false
+        )
+      };
+      break;
+    case "url": {
+      object(raw, ["type", "url"]);
+      const maxUrlLength = 2048;
+      const url = text(raw["url"], "url", maxUrlLength);
+      let parsed;
+      try {
+        parsed = new URL(url);
+      } catch {
+        return invalid("Invalid source URL");
+      }
+      if (!["http:", "https:"].includes(parsed.protocol) || !parsed.hostname || parsed.username || parsed.password) {
+        return invalid("Source URL must be HTTP(S) without credentials");
+      }
+      if (parsed.href.length > maxUrlLength) {
+        return invalid(
+          `Source URL is too long (maximum ${maxUrlLength} characters after normalization)`
+        );
+      }
+      locator = { type: "url", url: parsed.href };
+      break;
+    }
+    default:
+      return invalid("Unknown source locator type");
+  }
+  return {
+    title,
+    locator,
+    ...description !== void 0 ? { description } : {}
+  };
+}
+__name(validateSessionSourceInput, "validateSessionSourceInput");
+function sessionSourceId(sessionId, locator, workspaceCwd) {
+  return createHash("sha256").update(JSON.stringify([sessionId, locator, workspaceCwd ?? null])).digest("hex");
+}
+__name(sessionSourceId, "sessionSourceId");
+function ordered(sources) {
+  return sources.sort(
+    (a, b) => b.createdAt.localeCompare(a.createdAt) || a.id.localeCompare(b.id)
+  );
+}
+__name(ordered, "ordered");
+function parseSessionSourcesSnapshot(value, sessionId) {
+  const raw = object(value, ["version", "revision", "sources"]);
+  if (raw["version"] !== 1 || !Number.isSafeInteger(raw["revision"]) || raw["revision"] < 0 || !Array.isArray(raw["sources"]) || raw["sources"].length > 200) {
+    return invalid("Unsupported or malformed sources snapshot");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const sources = raw["sources"].map((value2) => {
+    const source = object(value2, [
+      "id",
+      "kind",
+      "workspaceCwd",
+      "createdAt",
+      "updatedAt",
+      "title",
+      "description",
+      "locator"
+    ]);
+    const input = validateSessionSourceInput({
+      title: source["title"],
+      locator: source["locator"],
+      ...source["description"] !== void 0 ? { description: source["description"] } : {}
+    });
+    const workspaceCwd = source["workspaceCwd"];
+    if (input.locator.type === "workspace_file" ? typeof workspaceCwd !== "string" || !path.isAbsolute(workspaceCwd) || path.normalize(workspaceCwd) !== workspaceCwd : workspaceCwd !== void 0) {
+      return invalid("Invalid source workspace binding");
+    }
+    const id = sessionSourceId(
+      sessionId,
+      input.locator,
+      workspaceCwd
+    );
+    const kind = input.locator.type === "url" ? "link" : "file";
+    const createdAt = source["createdAt"];
+    const updatedAt = source["updatedAt"];
+    const isTimestamp = /* @__PURE__ */ __name((value3) => typeof value3 === "string" && Number.isFinite(Date.parse(value3)) && new Date(value3).toISOString() === value3, "isTimestamp");
+    if (source["id"] !== id || ids.has(id) || source["kind"] !== kind || !isTimestamp(createdAt) || !isTimestamp(updatedAt) || updatedAt < createdAt || source["title"] !== input.title || source["description"] !== input.description) {
+      return invalid("Invalid stored source");
+    }
+    ids.add(id);
+    return {
+      ...input,
+      id,
+      kind,
+      ...typeof workspaceCwd === "string" ? { workspaceCwd } : {},
+      createdAt,
+      updatedAt
+    };
+  });
+  return {
+    version: 1,
+    revision: raw["revision"],
+    sources: ordered(sources)
+  };
+}
+__name(parseSessionSourcesSnapshot, "parseSessionSourcesSnapshot");
+function restoreSessionSources(records, sessionId) {
+  const latest = records.findLast(
+    (record) => record.type === "system" && record.subtype === "session_sources_snapshot"
+  );
+  if (!latest) return {};
+  try {
+    return {
+      sourcesSnapshot: parseSessionSourcesSnapshot(
+        latest.systemPayload,
+        sessionId
+      )
+    };
+  } catch {
+    return { sourcesUnavailable: true };
+  }
+}
+__name(restoreSessionSources, "restoreSessionSources");
+var SessionSourceService = class {
+  constructor(options) {
+    this.options = options;
+  }
+  static {
+    __name(this, "SessionSourceService");
+  }
+  snapshot = {
+    version: 1,
+    revision: 0,
+    sources: []
+  };
+  loaded = false;
+  queue = Promise.resolve();
+  serial(operation) {
+    const result = this.queue.then(async () => {
+      if (!this.loaded) {
+        let restored;
+        try {
+          restored = await this.options.load();
+        } catch {
+          throw new SessionSourceError(
+            "source_persistence_unavailable",
+            "Stored sources could not be loaded"
+          );
+        }
+        if (restored.sourcesUnavailable)
+          throw new SessionSourceError(
+            "source_persistence_unavailable",
+            "Stored sources are unavailable"
+          );
+        this.snapshot = restored.sourcesSnapshot ?? {
+          version: 1,
+          revision: 0,
+          sources: []
+        };
+        this.loaded = true;
+      }
+      return operation();
+    });
+    this.queue = result.catch(() => void 0);
+    return result;
+  }
+  async commit(sources) {
+    const next = parseSessionSourcesSnapshot(
+      { version: 1, revision: this.snapshot.revision + 1, sources },
+      this.options.sessionId
+    );
+    try {
+      await this.options.persist(next);
+    } catch {
+      this.loaded = false;
+      throw new SessionSourceError(
+        "source_persistence_unavailable",
+        "Source metadata could not be persisted"
+      );
+    }
+    this.snapshot = next;
+    void Promise.resolve().then(() => this.options.notify?.(next.revision)).catch(() => void 0);
+  }
+  list() {
+    return this.serial(
+      async () => structuredClone({
+        revision: this.snapshot.revision,
+        sources: this.snapshot.sources
+      })
+    );
+  }
+  upsert(value) {
+    return this.serial(async () => {
+      const input = validateSessionSourceInput(value);
+      const workspaceCwd = input.locator.type === "workspace_file" ? path.resolve(this.options.workspaceCwd()) : void 0;
+      const id = sessionSourceId(
+        this.options.sessionId,
+        input.locator,
+        workspaceCwd
+      );
+      const previous = this.snapshot.sources.find((source2) => source2.id === id);
+      const description = input.description ?? previous?.description;
+      if (previous && previous.title === input.title && previous.description === description) {
+        return {
+          revision: this.snapshot.revision,
+          source: structuredClone(previous),
+          change: "unchanged"
+        };
+      }
+      if (!previous && this.snapshot.sources.length >= 200)
+        throw new SessionSourceError(
+          "source_limit_reached",
+          "A session can contain at most 200 sources"
+        );
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const source = {
+        ...input,
+        ...description !== void 0 ? { description } : {},
+        id,
+        kind: input.locator.type === "url" ? "link" : "file",
+        ...workspaceCwd ? { workspaceCwd } : {},
+        createdAt: previous?.createdAt ?? now,
+        updatedAt: now
+      };
+      await this.commit([
+        ...this.snapshot.sources.filter((item) => item.id !== id),
+        source
+      ]);
+      return {
+        revision: this.snapshot.revision,
+        source: structuredClone(source),
+        change: previous ? "updated" : "created"
+      };
+    });
+  }
+  remove(sourceId) {
+    return this.serial(async () => {
+      const sources = this.snapshot.sources.filter(
+        (source) => source.id !== sourceId
+      );
+      const removed = sources.length !== this.snapshot.sources.length;
+      if (removed) await this.commit(sources);
+      return { revision: this.snapshot.revision, removed };
+    });
+  }
+  copyFrom(sources, attachmentIds) {
+    return this.serial(async () => {
+      const warnings = [];
+      const cwd = path.resolve(this.options.workspaceCwd());
+      const copied = sources.flatMap((source) => {
+        if (source.locator.type === "attachment" && !attachmentIds.includes(source.locator.attachmentId) || source.locator.type === "workspace_file" && source.workspaceCwd !== cwd) {
+          warnings.push(
+            `Source ${source.id} was not copied because its resource could not be mapped`
+          );
+          return [];
+        }
+        return [
+          {
+            ...source,
+            id: sessionSourceId(
+              this.options.sessionId,
+              source.locator,
+              source.workspaceCwd
+            )
+          }
+        ];
+      });
+      if (copied.length) await this.commit(copied);
+      return { warnings };
+    });
+  }
+};
+
+export {
+  SessionSourceError,
+  validateSessionSourceInput,
+  restoreSessionSources,
+  SessionSourceService
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/chunk-ERU3SDXT.js

@@ -0,0 +1,27 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+
+// packages/core/src/utils/auth-type.ts
+init_esbuild_shims();
+var AuthType = /* @__PURE__ */ ((AuthType2) => {
+  AuthType2["USE_OPENAI"] = "openai";
+  AuthType2["USE_OPENAI_RESPONSES"] = "openai-responses";
+  AuthType2["QWEN_OAUTH"] = "qwen-oauth";
+  AuthType2["USE_GEMINI"] = "gemini";
+  AuthType2["USE_VERTEX_AI"] = "vertex-ai";
+  AuthType2["USE_ANTHROPIC"] = "anthropic";
+  return AuthType2;
+})(AuthType || {});
+
+export {
+  AuthType
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */