@qwen-code/qwen-code 0.19.10 → 0.19.11-nightly.20260717.f8e6e8931

package/chunks/{chunk-6OATMEYN.js → chunk-RTV5TUYB.js}

@@ -1,11 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  DEFAULT_QWEN_MODEL
-} from "./chunk-CARU2RR2.js";
 import {
   SchemaValidator
-} from "./chunk-2UUAIFQO.js";
+} from "./chunk-JGUT3LWZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -13,6 +10,13 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// packages/core/src/config/models.ts
+init_esbuild_shims();
+var DEFAULT_QWEN_MODEL = "coder-model";
+var DEFAULT_QWEN_FLASH_MODEL = "coder-model";
+var DEFAULT_QWEN_EMBEDDING_MODEL = "text-embedding-v4";
+var MAINLINE_CODER_MODEL = "qwen3.7-max";
+
 // packages/core/src/utils/sideQuery.ts
 init_esbuild_shims();
 import { readFile } from "node:fs/promises";
@@ -126,6 +130,10 @@ async function runSideQuery(config, options) {
 __name(runSideQuery, "runSideQuery");
 
 export {
+  DEFAULT_QWEN_MODEL,
+  DEFAULT_QWEN_FLASH_MODEL,
+  DEFAULT_QWEN_EMBEDDING_MODEL,
+  MAINLINE_CODER_MODEL,
   runSideQuery
 };
 /**

package/chunks/{chunk-6W6DI34P.js → chunk-SE6GSFAO.js}

@@ -2,10 +2,13 @@
 "use strict";
 import {
   HistoryReplayer
-} from "./chunk-4FMG7EDJ.js";
+} from "./chunk-AEKHQ3E5.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
+import {
+  getResponseText
+} from "./chunk-R6AO7HBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -423,6 +426,147 @@ async function replayTranscriptRecordPage({
 }
 __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");
+
+// packages/cli/src/config/mcp-server-secrets.ts
+init_esbuild_shims();
+var REDACTED_MCP_SECRET = "__redacted__";
+function recordOf(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+__name(recordOf, "recordOf");
+function redactRecord(record) {
+  return record ? Object.fromEntries(
+    Object.keys(record).map((key) => [key, REDACTED_MCP_SECRET])
+  ) : record;
+}
+__name(redactRecord, "redactRecord");
+function restoreRecord(incoming, prior) {
+  if (!incoming) return incoming;
+  const priorRecord = recordOf(prior);
+  const result = {};
+  for (const [key, value] of Object.entries(incoming)) {
+    if (value !== REDACTED_MCP_SECRET) {
+      result[key] = value;
+    } else if (typeof priorRecord[key] === "string") {
+      result[key] = priorRecord[key];
+    }
+  }
+  return result;
+}
+__name(restoreRecord, "restoreRecord");
+function redactMcpServerSecrets(server) {
+  return {
+    ...server,
+    env: redactRecord(server.env),
+    headers: redactRecord(server.headers),
+    ...server.oauth?.clientSecret ? {
+      oauth: {
+        ...server.oauth,
+        clientSecret: REDACTED_MCP_SECRET
+      }
+    } : {}
+  };
+}
+__name(redactMcpServerSecrets, "redactMcpServerSecrets");
+function restoreRedactedMcpSecrets(server, existing) {
+  const existingOauth = recordOf(existing["oauth"]);
+  const incomingSecret = server.oauth?.clientSecret;
+  const restoredSecret = incomingSecret === REDACTED_MCP_SECRET ? existingOauth["clientSecret"] : incomingSecret;
+  return {
+    ...server,
+    env: restoreRecord(server.env, existing["env"]),
+    headers: restoreRecord(server.headers, existing["headers"]),
+    ...server.oauth ? {
+      oauth: {
+        ...server.oauth,
+        ...typeof restoredSecret === "string" ? { clientSecret: restoredSecret } : { clientSecret: void 0 }
+      }
+    } : {}
+  };
+}
+__name(restoreRedactedMcpSecrets, "restoreRedactedMcpSecrets");
+function redactMcpServersSetting(value) {
+  const servers = recordOf(value);
+  return Object.fromEntries(
+    Object.entries(servers).map(([name, server]) => {
+      const record = recordOf(server);
+      return [name, redactMcpServerSecrets(record)];
+    })
+  );
+}
+__name(redactMcpServersSetting, "redactMcpServersSetting");
+function restoreRedactedMcpServersSetting(value, existing) {
+  const servers = recordOf(value);
+  const existingServers = recordOf(existing);
+  return Object.fromEntries(
+    Object.entries(servers).map(([name, server]) => {
+      const record = recordOf(server);
+      return [
+        name,
+        restoreRedactedMcpSecrets(record, recordOf(existingServers[name]))
+      ];
+    })
+  );
+}
+__name(restoreRedactedMcpServersSetting, "restoreRedactedMcpServersSetting");
+
 export {
   createWorkspaceMemoryExtractionErrorLogger,
   extractRememberErrorCode,
@@ -436,10 +580,23 @@ export {
   createReplayCumulativeUsage,
   copyCumulativeUsage,
   collectHistoryReplayUpdates,
-  replayTranscriptRecordPage
+  replayTranscriptRecordPage,
+  GENERATION_MAX_PROMPT_BYTES,
+  GENERATION_TIMEOUT_MS,
+  executeGeneration,
+  REDACTED_MCP_SECRET,
+  redactMcpServerSecrets,
+  restoreRedactedMcpSecrets,
+  redactMcpServersSetting,
+  restoreRedactedMcpServersSetting
 };
 /**
  * @license
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-WTSXKLG5.js → chunk-SUARMD4Q.js}

@@ -7,7 +7,7 @@ import {
   ansiRegex,
   init_ansi_regex,
   stripAnsi
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-T4TZQJ7W.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-T4TZQJ7W.js

@@ -0,0 +1,48 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __esm,
+  __export,
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// node_modules/ansi-regex/index.js
+var ansi_regex_exports = {};
+__export(ansi_regex_exports, {
+  default: () => ansiRegex
+});
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+var init_ansi_regex = __esm({
+  "node_modules/ansi-regex/index.js"() {
+    init_esbuild_shims();
+    __name(ansiRegex, "ansiRegex");
+  }
+});
+
+// node_modules/strip-ansi/index.js
+init_esbuild_shims();
+init_ansi_regex();
+var regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  return string.replace(regex, "");
+}
+__name(stripAnsi, "stripAnsi");
+
+export {
+  ansiRegex,
+  ansi_regex_exports,
+  init_ansi_regex,
+  stripAnsi
+};

package/chunks/{chunk-LTNI523B.js → chunk-T7CZYIAU.js}

@@ -2,10 +2,14 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-YX4LLZ3D.js";
+} from "./chunk-NABT4VOY.js";
 import {
   parseAndFormatApiError
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-R6AO7HBQ.js";
+import {
+  formatVisionBridgeNoticeDisplay,
+  isVisionBridgeNoticeDisplay
+} from "./chunk-BTSE2DUP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -792,7 +796,7 @@ ${event.value}`, null);
    * to emit stream events when includePartialMessages is enabled.
    *
    * @param _request - Tool call request info
-   * @param _progress - Structured MCP progress data
+   * @param _progress - Structured MCP progress data or shell liveness heartbeat
    */
   emitToolProgress(_request, _progress) {
   }
@@ -921,13 +925,32 @@ function checkResponsePartsForError(responseParts) {
 }
 __name(checkResponsePartsForError, "checkResponsePartsForError");
 function toolResultContent(response) {
-  if (response.error) {
-    return response.error.message;
+  if (isVisionBridgeNoticeDisplay(response.resultDisplay)) {
+    const notice = formatVisionBridgeNoticeDisplay(response.resultDisplay);
+    if (response.error) {
+      return `${notice}
+${response.error.message}`;
+    }
+    const responsePartsError2 = checkResponsePartsForError(
+      response.responseParts
+    );
+    if (responsePartsError2) {
+      return `${notice}
+${responsePartsError2}`;
+    }
+    if (response.responseParts && response.responseParts.length > 0) {
+      return `${notice}
+${functionResponsePartsToString(response.responseParts)}`;
+    }
+    return notice;
   }
   const responsePartsError = checkResponsePartsForError(response.responseParts);
   if (responsePartsError) {
     return responsePartsError;
   }
+  if (response.error) {
+    return response.error.message;
+  }
   if (typeof response.resultDisplay === "string" && response.resultDisplay.trim().length > 0) {
     return response.resultDisplay;
   }

package/chunks/{chunk-3MX7D6QN.js → chunk-TIOE2OPE.js}

@@ -1,8 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  ChannelWorkerStartupError
+} from "./chunk-6WGZDD67.js";
 import {
   ChannelWebhookEnqueueError
-} from "./chunk-OJAMDVF5.js";
+} from "./chunk-KSZKSE23.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -19,12 +22,18 @@ var ChannelWorkerReconcileError = class extends Error {
   rolledBack;
   rollbackError;
   stopFailed;
+  startupFailures;
+  startupFailuresTruncated;
   constructor(message, options) {
     super(message);
     this.name = "ChannelWorkerReconcileError";
     this.rolledBack = options.rolledBack;
     this.rollbackError = options.rollbackError;
     this.stopFailed = options.stopFailed === true;
+    this.startupFailures = options.startupFailures?.map((failure) => ({
+      ...failure
+    }));
+    this.startupFailuresTruncated = options.startupFailuresTruncated;
   }
 };
 var DISABLED_SNAPSHOT = {
@@ -45,6 +54,14 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 __name(errorMessage, "errorMessage");
+function startupFailureDetails(error) {
+  if (!(error instanceof ChannelWorkerStartupError)) return {};
+  return {
+    startupFailures: error.startupFailures,
+    ...error.startupFailuresTruncated ? { startupFailuresTruncated: true } : {}
+  };
+}
+__name(startupFailureDetails, "startupFailureDetails");
 function createChannelWorkerGroup(opts) {
   let generation = 0;
   let entries = /* @__PURE__ */ new Map();
@@ -60,6 +77,11 @@ function createChannelWorkerGroup(opts) {
   let groupStarted = false;
   const withMeta = /* @__PURE__ */ __name((entry, snapshot) => ({
     ...snapshot,
+    ...snapshot.startupFailures ? {
+      startupFailures: snapshot.startupFailures.map((failure) => ({
+        ...failure
+      }))
+    } : {},
     workspaceId: entry.workspaceId,
     workspaceCwd: entry.workspaceCwd,
     primary: entry.primary
@@ -341,6 +363,7 @@ function createChannelWorkerGroup(opts) {
           }
         } catch (error) {
           reconcileOptions?.onRollingBack?.();
+          const startupDetails = startupFailureDetails(error);
           const cleanup = await stopEntriesForRollback(startedNew);
           if (cleanup.error) {
             for (const entry of cleanup.failedEntries) {
@@ -348,16 +371,21 @@ function createChannelWorkerGroup(opts) {
             }
             throw new ChannelWorkerReconcileError(errorMessage(error), {
               rolledBack: false,
-              rollbackError: cleanup.error
+              rollbackError: cleanup.error,
+              ...startupDetails
             });
           }
           if (stopping) {
             throw new ChannelWorkerReconcileError(errorMessage(error), {
-              rolledBack: false
+              rolledBack: false,
+              ...startupDetails
             });
           }
           const rollback = await restoreEntries(stoppedOld);
-          throw new ChannelWorkerReconcileError(errorMessage(error), rollback);
+          throw new ChannelWorkerReconcileError(errorMessage(error), {
+            ...rollback,
+            ...startupDetails
+          });
         }
         const committed = new Map(unchanged);
         for (const entry of newEntries) {