@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260701.a974594d7

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

@@ -1,5 +1,22 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  buildPermissionSettings
+} from "./chunk-DBR7PF4B.js";
+import {
+  resolveVoiceStreamConfig,
+  resolveVoiceTranscriptionConfig,
+  transcribeVoiceAudio
+} from "./chunk-T44AF4I6.js";
+import {
+  getVoiceSettingsScope,
+  isSelectableVoiceModel,
+  isVoiceEnabled,
+  readVoiceLanguage,
+  readVoiceMode,
+  readVoiceModel,
+  resolveVoiceTransport
+} from "./chunk-LXEW6BHF.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-P7M4GA57.js";
@@ -11,10 +28,15 @@ import {
   WorkspaceInitPathEscapeError,
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError
-} from "./chunk-S566HKUS.js";
+} from "./chunk-DHXWNSJA.js";
 import {
-  writeStderrLine
-} from "./chunk-Y6Z2O3WR.js";
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSettingsPartialPersistError
+} from "./chunk-BMFMJINR.js";
+import {
+  getPersistScopeForModelSelection,
+  loadSettings
+} from "./chunk-6FIWYVN4.js";
 import {
   SERVE_CONTROL_EXT_METHODS,
   SERVE_STATUS_EXT_METHODS,
@@ -27,7 +49,19 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-D5E5TMYH.js";
+} from "./chunk-VHRREANT.js";
+import {
+  getWorkspaceTrustStatus
+} from "./chunk-Z34RYLRO.js";
+import {
+  writeStderrLine
+} from "./chunk-Y6Z2O3WR.js";
+import {
+  ModelsConfig
+} from "./chunk-35FH347N.js";
+import {
+  createDebugLogger
+} from "./chunk-AVQDCKNF.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

package/chunks/{chunk-TOEGRAVX.js → chunk-JV7A66DR.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -14140,10 +14140,22 @@ var ajvOptions = {
   // strictSchema defaults to true and prevents use of JSON schemas that
   // include unrecognized keywords. The JSON schema spec specifically allows
   // for the use of non-standard keywords and the spec-compliant behavior
-  // is to ignore those keywords. Note that setting this to false also
-  // allows use of non-standard or custom formats (the unknown format value
-  // will be logged but the schema will still be considered valid).
-  strictSchema: false
+  // is to ignore those keywords.
+  strictSchema: false,
+  // Ajv still validates known formats, but MCP/OpenAPI schemas often include
+  // annotation-only formats like uint64 that would otherwise spam stderr.
+  logger: {
+    // eslint-disable-next-line no-console
+    log: /* @__PURE__ */ __name((...args) => console.log(...args), "log"),
+    warn: /* @__PURE__ */ __name((...args) => {
+      if (typeof args[0] === "string" && args[0].startsWith("unknown format ")) {
+        return;
+      }
+      console.warn(...args);
+    }, "warn"),
+    // eslint-disable-next-line no-console
+    error: /* @__PURE__ */ __name((...args) => console.error(...args), "error")
+  }
 };
 var ajvDefault = new AjvClass(ajvOptions);
 var ajv2020 = new Ajv2020Class(ajvOptions);
@@ -14999,9 +15011,9 @@ var AgentStatistics = class {
     const stats = this.getSummary(now);
     const sr = stats.totalToolCalls > 0 ? stats.successRate ?? stats.successfulToolCalls / stats.totalToolCalls * 100 : 0;
     const lines = [
-      `\u{1F4CB} Task Completed: ${taskDesc}`,
-      `\u{1F527} Tool Usage: ${stats.totalToolCalls} calls${stats.totalToolCalls ? `, ${sr.toFixed(1)}% success` : ""}`,
-      `\u23F1\uFE0F Duration: ${this.fmtDuration(stats.totalDurationMs)} | \u{1F501} Rounds: ${stats.rounds}`
+      `\u25B8 Task Completed: ${taskDesc}`,
+      `\u25CF Tool Usage: ${stats.totalToolCalls} calls${stats.totalToolCalls ? `, ${sr.toFixed(1)}% success` : ""}`,
+      `\u25CF Duration: ${this.fmtDuration(stats.totalDurationMs)} | \u25CF Rounds: ${stats.rounds}`
     ];
     if (typeof stats.totalTokens === "number") {
       const parts = [
@@ -15009,7 +15021,7 @@ var AgentStatistics = class {
         `out ${stats.outputTokens ?? 0}`
       ];
       lines.push(
-        `\u{1F522} Tokens: ${stats.totalTokens.toLocaleString()}${parts.length ? ` (${parts.join(", ")})` : ""}`
+        `\u25CF Tokens: ${stats.totalTokens.toLocaleString()}${parts.length ? ` (${parts.join(", ")})` : ""}`
       );
     }
     return lines.join("\n");
@@ -15018,23 +15030,23 @@ var AgentStatistics = class {
     const stats = this.getSummary(now);
     const sr = stats.totalToolCalls > 0 ? stats.successRate ?? stats.successfulToolCalls / stats.totalToolCalls * 100 : 0;
     const lines = [];
-    lines.push(`\u{1F4CB} Task Completed: ${taskDesc}`);
+    lines.push(`\u25B8 Task Completed: ${taskDesc}`);
     lines.push(
-      `\u23F1\uFE0F Duration: ${this.fmtDuration(stats.totalDurationMs)} | \u{1F501} Rounds: ${stats.rounds}`
+      `\u25CF Duration: ${this.fmtDuration(stats.totalDurationMs)} | \u25CF Rounds: ${stats.rounds}`
     );
     let quality = "Poor execution";
     if (sr >= 95) quality = "Excellent execution";
     else if (sr >= 85) quality = "Good execution";
     else if (sr >= 70) quality = "Fair execution";
-    lines.push(`\u2705 Quality: ${quality} (${sr.toFixed(1)}% tool success)`);
+    lines.push(`\u2713 Quality: ${quality} (${sr.toFixed(1)}% tool success)`);
     const d = stats.totalDurationMs;
     let speed = "Long execution - consider breaking down tasks";
     if (d < 1e4) speed = "Fast completion - under 10 seconds";
     else if (d < 6e4) speed = "Good speed - under a minute";
     else if (d < 3e5) speed = "Moderate duration - a few minutes";
-    lines.push(`\u{1F680} Speed: ${speed}`);
+    lines.push(`\u25CF Speed: ${speed}`);
     lines.push(
-      `\u{1F527} Tools: ${stats.totalToolCalls} calls, ${sr.toFixed(1)}% success (${stats.successfulToolCalls} ok, ${stats.failedToolCalls} failed)`
+      `\u25CF Tools: ${stats.totalToolCalls} calls, ${sr.toFixed(1)}% success (${stats.successfulToolCalls} ok, ${stats.failedToolCalls} failed)`
     );
     if (typeof stats.totalTokens === "number") {
       const parts = [
@@ -15042,7 +15054,7 @@ var AgentStatistics = class {
         `out ${stats.outputTokens ?? 0}`
       ];
       lines.push(
-        `\u{1F522} Tokens: ${stats.totalTokens.toLocaleString()} (${parts.join(", ")})`
+        `\u25CF Tokens: ${stats.totalTokens.toLocaleString()} (${parts.join(", ")})`
       );
     }
     if (stats.toolUsage && stats.toolUsage.length) {
@@ -15057,7 +15069,7 @@ var AgentStatistics = class {
     }
     const tips = this.generatePerformanceTips(stats);
     if (tips.length) {
-      lines.push("\n\u{1F4A1} Performance Insights:");
+      lines.push("\n\u2605 Performance Insights:");
       for (const tip of tips.slice(0, 3)) lines.push(` - ${tip}`);
     }
     return lines.join("\n");

package/chunks/{chunk-3RJ3ZPPR.js → chunk-KKQWC6WS.js}

@@ -7,13 +7,15 @@ import {
   SETTINGS_DIRECTORY_NAME,
   V1_INDICATOR_KEYS,
   getGlobalQwenDirLite,
-  getPathComparisonVariants,
   getSystemDefaultsPath,
   getSystemSettingsPath,
-  isWithinRoot,
-  require_strip_json_comments,
   resolveEnvVarsInObject
-} from "./chunk-UN3C6GOR.js";
+} from "./chunk-PPFWEV7G.js";
+import {
+  getPathComparisonVariants,
+  isWithinRoot,
+  require_strip_json_comments
+} from "./chunk-QYUE6W3T.js";
 import {
   require_main
 } from "./chunk-SKAZWEV5.js";
@@ -272,9 +274,7 @@ function readTrustedFolderRulesFastPath() {
 __name(readTrustedFolderRulesFastPath, "readTrustedFolderRulesFastPath");
 function buildTrustedFolderRules(trustedFolders) {
   const rules = [];
-  for (const [rulePath, trustLevel] of Object.entries(
-    trustedFolders
-  )) {
+  for (const [rulePath, trustLevel] of Object.entries(trustedFolders)) {
     if (trustLevel === TRUST_FOLDER) {
       rules.push({
         level: "trusted",

package/chunks/{chunk-EXMX5YHG.js → chunk-KXVVXAAC.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-UFC57OYT.js";
 import {
   MissingCliEntryError
-} from "./chunk-D5E5TMYH.js";
+} from "./chunk-VHRREANT.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-Z7XXFPGP.js → chunk-LDWTYE33.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-JXQ23SNT.js";
+} from "./chunk-2JKEQWDZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-X6EDWN44.js → chunk-LWGLBVWA.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-NYOHZYHM.js → chunk-LXEW6BHF.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-5JZLXFPD.js";
+} from "./chunk-3O2BJMFW.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -10,7 +10,7 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/cli/src/ui/voice/voice-model.ts
+// packages/cli/src/services/voice-model.ts
 init_esbuild_shims();
 function resolveVoiceTransport(model) {
   const id = model.toLowerCase();
@@ -44,11 +44,53 @@ function formatUnsupportedVoiceModelMessage(modelName) {
 }
 __name(formatUnsupportedVoiceModelMessage, "formatUnsupportedVoiceModelMessage");
 
+// packages/cli/src/services/voice-settings.ts
+init_esbuild_shims();
+function readVoiceModel(settings) {
+  const value = settings.merged?.voiceModel;
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+__name(readVoiceModel, "readVoiceModel");
+function isVoiceEnabled(settings) {
+  return settings.merged?.general?.voice?.enabled === true;
+}
+__name(isVoiceEnabled, "isVoiceEnabled");
+function readVoiceMode(settings) {
+  return settings.merged?.general?.voice?.mode === "tap" ? "tap" : "hold";
+}
+__name(readVoiceMode, "readVoiceMode");
+function readVoiceLanguage(settings) {
+  const language = settings.merged.general?.voice?.language;
+  if (typeof language !== "string") {
+    return "";
+  }
+  return language.trim();
+}
+__name(readVoiceLanguage, "readVoiceLanguage");
+function getVoiceSettingsScope(settings, workspaceTrusted = settings.isTrusted === true) {
+  return workspaceTrusted && typeof settings.workspace?.settings?.general?.voice?.enabled === "boolean" ? "Workspace" /* Workspace */ : "User" /* User */;
+}
+__name(getVoiceSettingsScope, "getVoiceSettingsScope");
+function isVoiceMode(value) {
+  return value === "hold" || value === "tap";
+}
+__name(isVoiceMode, "isVoiceMode");
+
 export {
   resolveVoiceTransport,
   isTranscribableVoiceModel,
   isSelectableVoiceModel,
-  formatUnsupportedVoiceModelMessage
+  formatUnsupportedVoiceModelMessage,
+  readVoiceModel,
+  isVoiceEnabled,
+  readVoiceMode,
+  readVoiceLanguage,
+  getVoiceSettingsScope,
+  isVoiceMode
 };
 /**
  * @license