@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260630.e00fe6a27

package/chunks/{chunk-3UALQ56H.js → chunk-3227DZO4.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-BGUDAULQ.js → chunk-3CPCDXFR.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   formatFetchErrorForUser
-} from "./chunk-EW6C27XX.js";
+} from "./chunk-GEHVIWAT.js";
 import {
   openBrowserSecurely
 } from "./chunk-22IFUCVR.js";
+import {
+  atomicWriteFile
+} from "./chunk-3227DZO4.js";
 import {
   combineAbortSignals
 } from "./chunk-64WXLC72.js";
-import {
-  atomicWriteFile
-} from "./chunk-3UALQ56H.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-5RVSM6NW.js → chunk-3HUHAQF3.js}

@@ -6,7 +6,7 @@ import {
   getNestedProperty,
   getPersistScopeForModelSelection,
   restoreSettingsFromBackup
-} from "./chunk-OQHQHJRK.js";
+} from "./chunk-HEVBZSXG.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-D5E5TMYH.js → chunk-3M4W4U5G.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   SkillError
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-RIP623NO.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -51,6 +51,7 @@ var MissingCliEntryError = class extends Error {
 var SERVE_STATUS_EXT_METHODS = {
   workspaceMcp: "qwen/status/workspace/mcp",
   workspaceMcpTools: "qwen/status/workspace/mcp/tools",
+  workspaceMcpResources: "qwen/status/workspace/mcp/resources",
   workspaceSkills: "qwen/status/workspace/skills",
   workspaceTools: "qwen/status/workspace/tools",
   workspaceProviders: "qwen/status/workspace/providers",
@@ -78,6 +79,7 @@ var SERVE_CONTROL_EXT_METHODS = {
   sessionShellHistory: "qwen/control/session/shell_history",
   sessionLanguage: "qwen/control/session/language",
   sessionRewind: "qwen/control/session/rewind",
+  sessionContinue: "qwen/control/session/continue",
   sessionTitle: "qwen/control/session/title",
   workspaceMcpRestart: "qwen/control/workspace/mcp/restart",
   workspaceMcpManage: "qwen/control/workspace/mcp/manage",
@@ -88,7 +90,19 @@ var SERVE_CONTROL_EXT_METHODS = {
   workspaceMcpRuntimeAdd: "qwen/control/workspace/mcp/runtime-add",
   workspaceMcpRuntimeRemove: "qwen/control/workspace/mcp/runtime-remove",
   workspaceReload: "qwen/control/workspace/reload",
-  workspaceExtensionsRefresh: "qwen/control/workspace/extensions/refresh"
+  workspaceExtensionsRefresh: "qwen/control/workspace/extensions/refresh",
+  /**
+   * Reverse tool channel (issue #5626, Phase 2). Unlike every other entry
+   * here — which the PARENT serve process calls DOWN into the `qwen --acp`
+   * child — this one is called by the CHILD UP into the parent: a
+   * client-hosted (extension) MCP server's `sendSdkMcpMessage` round-trips a
+   * JSON-RPC `mcp_message` from the child's `McpClientManager` back to the
+   * parent's `ClientMcpRegistrar`, which pushes it down the daemon WS to the
+   * client and returns the correlated response. Params: `{ server, payload }`;
+   * result: `{ payload }`.
+   */
+  clientMcpMessage: "qwen/control/client_mcp/message",
+  sessionCd: "qwen/control/session/cd"
 };
 var IDLE_HOOK_EVENTS = {
   PreToolUse: { description: "Before tool execution", matcherKind: "toolName" },

package/chunks/{chunk-DBZUXSSV.js → chunk-4X7NIEQJ.js}

@@ -8,14 +8,14 @@ import {
 } from "./chunk-5DWXLGOM.js";
 import {
   loadSettings
-} from "./chunk-OQHQHJRK.js";
+} from "./chunk-HEVBZSXG.js";
 import {
   writeStderrLine
 } from "./chunk-Y6Z2O3WR.js";
 import {
   MCP_BUDGET_WARN_FRACTION,
   parsePositiveIntegerEnv
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-RIP623NO.js";
 import {
   openBrowserSecurely,
   shouldLaunchBrowser
@@ -257,7 +257,7 @@ var serveCommand = {
         process.exit(1);
       }
     }
-    const { runQwenServe } = await import("./run-qwen-serve-REKSTYRA.js");
+    const { runQwenServe } = await import("./run-qwen-serve-4B5QBMLQ.js");
     try {
       const handle = await runQwenServe({
         port: argv.port,

package/chunks/chunk-5GOVVXEV.js

@@ -0,0 +1,73 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  themeManager
+} from "./chunk-I4H7PRWQ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+
+// packages/cli/src/ui/colors.ts
+init_esbuild_shims();
+var Colors = {
+  get type() {
+    return themeManager.getActiveTheme().colors.type;
+  },
+  get Foreground() {
+    return themeManager.getActiveTheme().colors.Foreground;
+  },
+  get Background() {
+    return themeManager.getActiveTheme().colors.Background;
+  },
+  get LightBlue() {
+    return themeManager.getActiveTheme().colors.LightBlue;
+  },
+  get AccentBlue() {
+    return themeManager.getActiveTheme().colors.AccentBlue;
+  },
+  get AccentPurple() {
+    return themeManager.getActiveTheme().colors.AccentPurple;
+  },
+  get AccentCyan() {
+    return themeManager.getActiveTheme().colors.AccentCyan;
+  },
+  get AccentGreen() {
+    return themeManager.getActiveTheme().colors.AccentGreen;
+  },
+  get AccentYellow() {
+    return themeManager.getActiveTheme().colors.AccentYellow;
+  },
+  get AccentRed() {
+    return themeManager.getActiveTheme().colors.AccentRed;
+  },
+  get AccentYellowDim() {
+    return themeManager.getActiveTheme().colors.AccentYellowDim;
+  },
+  get AccentRedDim() {
+    return themeManager.getActiveTheme().colors.AccentRedDim;
+  },
+  get DiffAdded() {
+    return themeManager.getActiveTheme().colors.DiffAdded;
+  },
+  get DiffRemoved() {
+    return themeManager.getActiveTheme().colors.DiffRemoved;
+  },
+  get Comment() {
+    return themeManager.getActiveTheme().colors.Comment;
+  },
+  get Gray() {
+    return themeManager.getActiveTheme().colors.Gray;
+  },
+  get GradientColors() {
+    return themeManager.getActiveTheme().colors.GradientColors;
+  }
+};
+
+export {
+  Colors
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-2BAQ3ACS.js → chunk-5SM4VT6V.js}

@@ -1,5 +1,22 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  buildPermissionSettings
+} from "./chunk-WN6K47NR.js";
+import {
+  resolveVoiceStreamConfig,
+  resolveVoiceTranscriptionConfig,
+  transcribeVoiceAudio
+} from "./chunk-HFQ2XSE7.js";
+import {
+  getVoiceSettingsScope,
+  isSelectableVoiceModel,
+  isVoiceEnabled,
+  readVoiceLanguage,
+  readVoiceMode,
+  readVoiceModel,
+  resolveVoiceTransport
+} from "./chunk-5XQ4A26L.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-P7M4GA57.js";
@@ -11,10 +28,7 @@ import {
   WorkspaceInitPathEscapeError,
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError
-} from "./chunk-S566HKUS.js";
-import {
-  writeStderrLine
-} from "./chunk-Y6Z2O3WR.js";
+} from "./chunk-DHXWNSJA.js";
 import {
   SERVE_CONTROL_EXT_METHODS,
   SERVE_STATUS_EXT_METHODS,
@@ -27,7 +41,27 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-D5E5TMYH.js";
+} from "./chunk-3M4W4U5G.js";
+import {
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSettingsPartialPersistError
+} from "./chunk-BMFMJINR.js";
+import {
+  getPersistScopeForModelSelection,
+  loadSettings
+} from "./chunk-HEVBZSXG.js";
+import {
+  getWorkspaceTrustStatus
+} from "./chunk-ARYCHZ4B.js";
+import {
+  writeStderrLine
+} from "./chunk-Y6Z2O3WR.js";
+import {
+  ModelsConfig
+} from "./chunk-RIP623NO.js";
+import {
+  createDebugLogger
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -39,6 +73,231 @@ import {
 init_esbuild_shims();
 import { promises as fs, constants as fsConstants } from "node:fs";
 import * as path from "node:path";
+
+// packages/cli/src/services/voice-service.ts
+init_esbuild_shims();
+var debugLogger = createDebugLogger("VOICE_SERVICE");
+var EMPTY_WORKSPACE_VOICE_UPDATE_ERROR = "At least one of `enabled`, `mode`, `language`, or `voiceModel` must be provided";
+var WorkspaceVoiceError = class extends Error {
+  static {
+    __name(this, "WorkspaceVoiceError");
+  }
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.name = "WorkspaceVoiceError";
+    this.status = status;
+    this.code = code;
+  }
+};
+function voiceSettingsScopeToWire(scope) {
+  return scope === "Workspace" /* Workspace */ ? "workspace" : "user";
+}
+__name(voiceSettingsScopeToWire, "voiceSettingsScopeToWire");
+function buildWorkspaceVoiceSettingsWrites(settings, update, opts = {}) {
+  const voiceSettingsScope = getVoiceSettingsScope(
+    settings,
+    opts.workspaceTrusted
+  );
+  const writes = [];
+  if (update.voiceModel !== void 0) {
+    writes.push({
+      scope: getPersistScopeForModelSelection(settings),
+      key: "voiceModel",
+      value: update.voiceModel
+    });
+  }
+  if (update.mode !== void 0) {
+    writes.push({
+      scope: voiceSettingsScope,
+      key: "general.voice.mode",
+      value: update.mode
+    });
+  }
+  if (update.language !== void 0) {
+    writes.push({
+      scope: voiceSettingsScope,
+      key: "general.voice.language",
+      value: update.language
+    });
+  }
+  if (update.enabled !== void 0) {
+    writes.push({
+      scope: voiceSettingsScope,
+      key: "general.voice.enabled",
+      value: update.enabled
+    });
+  }
+  return writes;
+}
+__name(buildWorkspaceVoiceSettingsWrites, "buildWorkspaceVoiceSettingsWrites");
+function createVoiceModelSource(settings) {
+  return new ModelsConfig({
+    modelProvidersConfig: settings.merged.modelProviders
+  });
+}
+__name(createVoiceModelSource, "createVoiceModelSource");
+function listAvailableVoiceModels(settings) {
+  const models = createVoiceModelSource(settings).getAllConfiguredModels();
+  const idCounts = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    idCounts.set(model.id, (idCounts.get(model.id) ?? 0) + 1);
+  }
+  const duplicateIds = [...idCounts.entries()].filter(([, count]) => count > 1).map(([id]) => id);
+  if (duplicateIds.length > 0) {
+    debugLogger.debug(
+      `Skipping duplicate voice model ids: ${duplicateIds.join(", ")}`
+    );
+  }
+  return models.filter((model) => (idCounts.get(model.id) ?? 0) === 1).filter(isSelectableVoiceModel).map((model) => ({
+    id: model.id,
+    transport: resolveVoiceTransport(model.id)
+  })).filter(
+    (model) => model.transport !== "unsupported"
+  );
+}
+__name(listAvailableVoiceModels, "listAvailableVoiceModels");
+function hasConfiguredBatchVoiceTranscriptionModel(settings) {
+  for (const model of listAvailableVoiceModels(settings)) {
+    if (model.transport !== "qwen-asr-chat") {
+      continue;
+    }
+    try {
+      validateWorkspaceVoiceConfig(settings, model.id);
+      return true;
+    } catch (err) {
+      debugLogger.debug(
+        `Skipping unavailable batch voice model '${model.id}': ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return false;
+}
+__name(hasConfiguredBatchVoiceTranscriptionModel, "hasConfiguredBatchVoiceTranscriptionModel");
+function buildWorkspaceVoiceStatus(workspaceCwd, settings) {
+  return {
+    v: 1,
+    workspaceCwd,
+    enabled: isVoiceEnabled(settings),
+    mode: readVoiceMode(settings),
+    language: readVoiceLanguage(settings),
+    voiceModel: readVoiceModel(settings) ?? null,
+    availableVoiceModels: listAvailableVoiceModels(settings)
+  };
+}
+__name(buildWorkspaceVoiceStatus, "buildWorkspaceVoiceStatus");
+function validateWorkspaceVoiceModel(settings, voiceModel) {
+  const models = createVoiceModelSource(settings).getAllConfiguredModels();
+  const matches = models.filter((model2) => model2.id === voiceModel);
+  if (matches.length === 0) {
+    throw new WorkspaceVoiceError(
+      400,
+      "unknown_voice_model",
+      `Voice model '${voiceModel}' is not configured.`
+    );
+  }
+  if (matches.length > 1) {
+    throw new WorkspaceVoiceError(
+      400,
+      "ambiguous_voice_model",
+      `Voice model '${voiceModel}' is ambiguous.`
+    );
+  }
+  const [model] = matches;
+  if (!model || !isSelectableVoiceModel(model)) {
+    throw new WorkspaceVoiceError(
+      400,
+      "unsupported_voice_model",
+      `Voice model '${voiceModel}' cannot be used for transcription.`
+    );
+  }
+  const transport = resolveVoiceTransport(model.id);
+  if (transport === "unsupported") {
+    throw new WorkspaceVoiceError(
+      400,
+      "unsupported_voice_model",
+      `Voice model '${voiceModel}' cannot be used for transcription.`
+    );
+  }
+  return { id: model.id, transport };
+}
+__name(validateWorkspaceVoiceModel, "validateWorkspaceVoiceModel");
+function validateWorkspaceVoiceConfig(settings, voiceModel) {
+  const descriptor = validateWorkspaceVoiceModel(settings, voiceModel);
+  try {
+    const config = createVoiceModelSource(settings);
+    if (descriptor.transport === "qwen-asr-chat") {
+      resolveVoiceTranscriptionConfig({ config, settings, voiceModel });
+    } else {
+      resolveVoiceStreamConfig({ config, settings, voiceModel });
+    }
+  } catch (err) {
+    throw new WorkspaceVoiceError(
+      400,
+      "invalid_voice_model",
+      err instanceof Error ? err.message : `Voice model '${voiceModel}' is not configured for transcription.`
+    );
+  }
+  return descriptor;
+}
+__name(validateWorkspaceVoiceConfig, "validateWorkspaceVoiceConfig");
+function validateWorkspaceVoiceState(settings, update) {
+  if (update.enabled === void 0 && update.mode === void 0 && update.language === void 0 && update.voiceModel === void 0) {
+    throw new WorkspaceVoiceError(
+      400,
+      "invalid_voice_update",
+      EMPTY_WORKSPACE_VOICE_UPDATE_ERROR
+    );
+  }
+  const nextEnabled = update.enabled ?? isVoiceEnabled(settings);
+  const nextVoiceModel = update.voiceModel ?? readVoiceModel(settings);
+  if (update.voiceModel) {
+    validateWorkspaceVoiceModel(settings, update.voiceModel);
+  }
+  if (!nextEnabled) {
+    return;
+  }
+  if (!nextVoiceModel) {
+    throw new WorkspaceVoiceError(
+      400,
+      "voice_model_required",
+      "A valid voiceModel is required before enabling voice."
+    );
+  }
+  validateWorkspaceVoiceConfig(settings, nextVoiceModel);
+}
+__name(validateWorkspaceVoiceState, "validateWorkspaceVoiceState");
+async function transcribeWorkspaceVoiceAudio(input) {
+  const descriptor = validateWorkspaceVoiceModel(
+    input.settings,
+    input.voiceModel
+  );
+  if (descriptor.transport !== "qwen-asr-chat") {
+    throw new WorkspaceVoiceError(
+      400,
+      "unsupported_voice_model",
+      `Voice model '${input.voiceModel}' requires realtime transcription, which is not supported by this daemon endpoint.`
+    );
+  }
+  const text = await transcribeVoiceAudio(
+    { data: input.data, mimeType: input.mimeType },
+    {
+      config: createVoiceModelSource(input.settings),
+      settings: input.settings,
+      voiceModel: input.voiceModel,
+      abortSignal: input.abortSignal
+    }
+  );
+  return {
+    text,
+    model: input.voiceModel,
+    transport: descriptor.transport
+  };
+}
+__name(transcribeWorkspaceVoiceAudio, "transcribeWorkspaceVoiceAudio");
+
+// packages/cli/src/serve/workspace-service/index.ts
 async function canonicalizeExistingAncestor(inputPath) {
   let current = inputPath;
   while (true) {
@@ -77,6 +336,8 @@ function createDaemonWorkspaceService(deps) {
     workspaceProvidersStatusProvider,
     isChannelLive,
     persistDisabledTools,
+    persistSetting,
+    persistSettings,
     queryWorkspaceStatus,
     invokeWorkspaceCommand,
     refreshExtensionsForAllSessions: refreshExtensionsForAllSessionsOnBridge,
@@ -185,7 +446,133 @@ function createDaemonWorkspaceService(deps) {
         () => createIdleWorkspaceExtensionsStatus(boundWorkspace)
       );
     },
+    async getWorkspaceTrustStatus(_ctx) {
+      return getWorkspaceTrustStatus(
+        loadSettings(boundWorkspace).merged,
+        boundWorkspace
+      );
+    },
+    async getWorkspacePermissionsStatus(_ctx) {
+      return buildPermissionSettings(loadSettings(boundWorkspace));
+    },
+    async getWorkspaceVoiceStatus(_ctx) {
+      return buildWorkspaceVoiceStatus(
+        boundWorkspace,
+        loadSettings(boundWorkspace)
+      );
+    },
     // -- Mutations --
+    async requestWorkspaceTrustChange(ctx, request) {
+      publishWorkspaceEvent({
+        type: "trust_change_requested",
+        data: {
+          workspaceCwd: boundWorkspace,
+          desiredState: request.desiredState,
+          ...request.reason !== void 0 ? { reason: request.reason } : {}
+        },
+        originatorClientId: ctx.originatorClientId
+      });
+      return {
+        accepted: false,
+        desiredState: request.desiredState,
+        requiresOperatorAction: true
+      };
+    },
+    async setWorkspacePermissionRules(ctx, request) {
+      const key = `permissions.${request.ruleType}`;
+      try {
+        const result = await invokeWorkspaceCommand(
+          "qwen/permissions/setRules",
+          {
+            cwd: boundWorkspace,
+            scope: request.scope,
+            ruleType: request.ruleType,
+            rules: request.rules
+          }
+        );
+        publishWorkspaceEvent({
+          type: "settings_changed",
+          data: { key, value: request.rules, scope: request.scope },
+          originatorClientId: ctx.originatorClientId
+        });
+        return result;
+      } catch (err) {
+        if (!(err instanceof SessionNotFoundError)) {
+          throw err;
+        }
+        throw new WorkspacePermissionRulesSessionRequiredError();
+      }
+    },
+    async setWorkspaceVoiceSettings(ctx, request) {
+      if (!persistSettings && !persistSetting) {
+        throw new WorkspaceVoiceError(
+          501,
+          "not_implemented",
+          "Workspace voice settings persistence is not available"
+        );
+      }
+      const settings = loadSettings(boundWorkspace);
+      validateWorkspaceVoiceState(settings, request);
+      const workspaceTrusted = getWorkspaceTrustStatus(settings.merged, boundWorkspace).effective.state === "trusted";
+      const writes = buildWorkspaceVoiceSettingsWrites(settings, request, {
+        workspaceTrusted
+      });
+      const publishWrite = /* @__PURE__ */ __name((write) => {
+        publishWorkspaceEvent({
+          type: "settings_changed",
+          data: {
+            key: write.key,
+            value: write.value,
+            scope: voiceSettingsScopeToWire(write.scope)
+          },
+          originatorClientId: ctx.originatorClientId
+        });
+      }, "publishWrite");
+      if (persistSettings) {
+        try {
+          await persistSettings(boundWorkspace, writes);
+        } catch (err) {
+          if (err instanceof WorkspaceSettingsPartialPersistError) {
+            for (const write of err.committedWrites) {
+              publishWrite(write);
+            }
+          }
+          throw err;
+        }
+        for (const write of writes) {
+          publishWrite(write);
+        }
+      } else {
+        const committed = [];
+        for (const write of writes) {
+          try {
+            await persistSetting(
+              boundWorkspace,
+              write.scope,
+              write.key,
+              write.value
+            );
+          } catch (err) {
+            writeStderrLine(
+              `qwen serve: workspace voice partial persist error (workspace=${boundWorkspace}, committed=${committed.length}/${writes.length}, failedKey=${write.key}, failedScope=${voiceSettingsScopeToWire(write.scope)}): ${err instanceof Error ? err.message : String(err)}`
+            );
+            throw new WorkspaceSettingsPartialPersistError(
+              `Voice settings partial persist failed: committed=${committed.length}/${writes.length}`,
+              committed,
+              err
+            );
+          }
+          committed.push(write);
+        }
+        for (const write of committed) {
+          publishWrite(write);
+        }
+      }
+      return buildWorkspaceVoiceStatus(
+        boundWorkspace,
+        loadSettings(boundWorkspace)
+      );
+    },
     async setWorkspaceToolEnabled(ctx, toolName, enabled) {
       await persistDisabledTools(boundWorkspace, toolName, enabled);
       publishWorkspaceEvent({
@@ -477,8 +864,21 @@ function createDaemonWorkspaceService(deps) {
 __name(createDaemonWorkspaceService, "createDaemonWorkspaceService");
 
 export {
+  EMPTY_WORKSPACE_VOICE_UPDATE_ERROR,
+  WorkspaceVoiceError,
+  voiceSettingsScopeToWire,
+  buildWorkspaceVoiceSettingsWrites,
+  hasConfiguredBatchVoiceTranscriptionModel,
+  buildWorkspaceVoiceStatus,
+  validateWorkspaceVoiceState,
+  transcribeWorkspaceVoiceAudio,
   createDaemonWorkspaceService
 };
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen Team