@qwen-code/qwen-code 0.19.2 → 0.19.3

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

@@ -1,5 +1,26 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  buildPermissionSettings
+} from "./chunk-ODLIHNOY.js";
+import {
+  resolveVoiceStreamConfig,
+  resolveVoiceTranscriptionConfig,
+  transcribeVoiceAudio
+} from "./chunk-BTLJ2MF5.js";
+import {
+  getVoiceSettingsScope,
+  isSelectableVoiceModel,
+  isVoiceEnabled,
+  readVoiceLanguage,
+  readVoiceMode,
+  readVoiceModel,
+  resolveVoiceTransport
+} from "./chunk-4LUZAKMK.js";
+import {
+  WorkspacePermissionRulesSessionRequiredError,
+  WorkspaceSettingsPartialPersistError
+} from "./chunk-BMFMJINR.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-P7M4GA57.js";
@@ -11,10 +32,11 @@ import {
   WorkspaceInitPathEscapeError,
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError
-} from "./chunk-S566HKUS.js";
+} from "./chunk-JE5FVRPC.js";
 import {
-  writeStderrLine
-} from "./chunk-Y6Z2O3WR.js";
+  getPersistScopeForModelSelection,
+  loadSettings
+} from "./chunk-FKAVULLM.js";
 import {
   SERVE_CONTROL_EXT_METHODS,
   SERVE_STATUS_EXT_METHODS,
@@ -27,7 +49,19 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-D5E5TMYH.js";
+} from "./chunk-L7OKCI7T.js";
+import {
+  getWorkspaceTrustStatus
+} from "./chunk-F3ZYSEY6.js";
+import {
+  writeStderrLine
+} from "./chunk-Y6Z2O3WR.js";
+import {
+  ModelsConfig
+} from "./chunk-YAINVQ3Q.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

package/chunks/{chunk-4W4T77MO.js → chunk-J7FA27RO.js}

@@ -2,16 +2,16 @@
 "use strict";
 import {
   getEffectiveSupportedModes
-} from "./chunk-JTYRZODB.js";
+} from "./chunk-3TV3HUWZ.js";
 import {
   require_jsx_runtime
-} from "./chunk-UAARJR2G.js";
+} from "./chunk-T4T2FNV4.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
 import {
   uiTelemetryService
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-QNKBEJO2.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -24,6 +24,12 @@ import {
 init_esbuild_shims();
 var import_react = __toESM(require_react(), 1);
 var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+var EMPTY_SKILL_METRICS = {
+  totalCalls: 0,
+  totalSuccess: 0,
+  totalFail: 0,
+  byName: {}
+};
 function areModelMetricsCoreEqual(a, b) {
   if (a.api.totalRequests !== b.api.totalRequests || a.api.totalErrors !== b.api.totalErrors || a.api.totalLatencyMs !== b.api.totalLatencyMs) {
     return false;
@@ -59,6 +65,27 @@ function areToolCallStatsEqual(a, b) {
   return true;
 }
 __name(areToolCallStatsEqual, "areToolCallStatsEqual");
+function areSkillCallStatsEqual(a, b) {
+  return a.count === b.count && a.success === b.success && a.fail === b.fail;
+}
+__name(areSkillCallStatsEqual, "areSkillCallStatsEqual");
+function areSkillMetricsEqual(a, b) {
+  if (a.totalCalls !== b.totalCalls || a.totalSuccess !== b.totalSuccess || a.totalFail !== b.totalFail) {
+    return false;
+  }
+  const aKeys = Object.keys(a.byName);
+  const bKeys = Object.keys(b.byName);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    const skillA = a.byName[key];
+    const skillB = b.byName[key];
+    if (!skillB || !areSkillCallStatsEqual(skillA, skillB)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(areSkillMetricsEqual, "areSkillMetricsEqual");
 function areMetricsEqual(a, b) {
   if (a === b) return true;
   if (!a || !b) return false;
@@ -83,6 +110,12 @@ function areMetricsEqual(a, b) {
       return false;
     }
   }
+  if (!areSkillMetricsEqual(
+    a.skills ?? EMPTY_SKILL_METRICS,
+    b.skills ?? EMPTY_SKILL_METRICS
+  )) {
+    return false;
+  }
   const modelsAKeys = Object.keys(a.models);
   const modelsBKeys = Object.keys(b.models);
   if (modelsAKeys.length !== modelsBKeys.length) return false;
@@ -94,13 +127,82 @@ function areMetricsEqual(a, b) {
   return true;
 }
 __name(areMetricsEqual, "areMetricsEqual");
+function cloneSessionMetrics(metrics) {
+  return {
+    models: Object.fromEntries(
+      Object.entries(metrics.models).map(([name, model]) => [
+        name,
+        {
+          api: { ...model.api },
+          tokens: { ...model.tokens },
+          bySource: Object.fromEntries(
+            Object.entries(model.bySource).map(([source, sourceMetrics]) => [
+              source,
+              {
+                api: { ...sourceMetrics.api },
+                tokens: { ...sourceMetrics.tokens }
+              }
+            ])
+          )
+        }
+      ])
+    ),
+    tools: {
+      totalCalls: metrics.tools.totalCalls,
+      totalSuccess: metrics.tools.totalSuccess,
+      totalFail: metrics.tools.totalFail,
+      totalDurationMs: metrics.tools.totalDurationMs,
+      totalDecisions: { ...metrics.tools.totalDecisions },
+      byName: Object.fromEntries(
+        Object.entries(metrics.tools.byName).map(([name, stats]) => [
+          name,
+          {
+            count: stats.count,
+            success: stats.success,
+            fail: stats.fail,
+            durationMs: stats.durationMs,
+            decisions: { ...stats.decisions }
+          }
+        ])
+      )
+    },
+    files: {
+      totalLinesAdded: metrics.files.totalLinesAdded,
+      totalLinesRemoved: metrics.files.totalLinesRemoved
+    },
+    ...metrics.skills ? {
+      skills: {
+        totalCalls: metrics.skills.totalCalls,
+        totalSuccess: metrics.skills.totalSuccess,
+        totalFail: metrics.skills.totalFail,
+        byName: Object.fromEntries(
+          Object.entries(metrics.skills.byName).map(([name, stats]) => [
+            name,
+            {
+              count: stats.count,
+              success: stats.success,
+              fail: stats.fail
+            }
+          ])
+        )
+      }
+    } : {}
+  };
+}
+__name(cloneSessionMetrics, "cloneSessionMetrics");
+function getMetricsForDisplay(sessionId) {
+  return cloneSessionMetrics(
+    sessionId ? uiTelemetryService.getMetricsForSession(sessionId) : uiTelemetryService.getMetrics()
+  );
+}
+__name(getMetricsForDisplay, "getMetricsForDisplay");
 var SessionStatsContext = (0, import_react.createContext)(
   void 0
 );
 var createDefaultStats = /* @__PURE__ */ __name((sessionId = "") => ({
   sessionId,
   sessionStartTime: /* @__PURE__ */ new Date(),
-  metrics: uiTelemetryService.getMetrics(),
+  metrics: getMetricsForDisplay(sessionId),
   lastPromptTokenCount: 0,
   promptCount: 0
 }), "createDefaultStats");
@@ -114,12 +216,13 @@ var SessionStatsProvider = /* @__PURE__ */ __name(({ sessionId, children }) => {
       lastPromptTokenCount
     }) => {
       setStats((prevState) => {
-        if (prevState.lastPromptTokenCount === lastPromptTokenCount && areMetricsEqual(prevState.metrics, metrics)) {
+        const nextMetrics = prevState.sessionId ? getMetricsForDisplay(prevState.sessionId) : cloneSessionMetrics(metrics);
+        if (prevState.lastPromptTokenCount === lastPromptTokenCount && areMetricsEqual(prevState.metrics, nextMetrics)) {
           return prevState;
         }
         return {
           ...prevState,
-          metrics,
+          metrics: nextMetrics,
           lastPromptTokenCount
         };
       });

package/chunks/{chunk-S566HKUS.js → chunk-JE5FVRPC.js}

@@ -1,8 +1,5 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  MAX_WORKSPACE_PATH_LENGTH
-} from "./chunk-SEZC2725.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -10,6 +7,24 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// packages/acp-bridge/src/workspacePaths.ts
+init_esbuild_shims();
+import { realpathSync } from "node:fs";
+import * as path from "node:path";
+function canonicalizeWorkspace(p) {
+  const resolved = path.resolve(p);
+  try {
+    return realpathSync.native(resolved);
+  } catch (err) {
+    if (err && typeof err === "object" && err.code === "ENOENT") {
+      return resolved;
+    }
+    throw err;
+  }
+}
+__name(canonicalizeWorkspace, "canonicalizeWorkspace");
+var MAX_WORKSPACE_PATH_LENGTH = 4096;
+
 // packages/acp-bridge/src/bridgeErrors.ts
 init_esbuild_shims();
 var NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE = "Not currently generating";
@@ -220,12 +235,12 @@ var WorkspaceInitConflictError = class extends Error {
   }
   path;
   existingSize;
-  constructor(path, existingSize) {
+  constructor(path2, existingSize) {
     super(
-      `Workspace file ${path} already exists (${existingSize} bytes); pass {force: true} to overwrite.`
+      `Workspace file ${path2} already exists (${existingSize} bytes); pass {force: true} to overwrite.`
     );
     this.name = "WorkspaceInitConflictError";
-    this.path = path;
+    this.path = path2;
     this.existingSize = existingSize;
   }
 };
@@ -331,8 +346,23 @@ var BranchWhilePromptActiveError = class extends Error {
     this.sessionId = sessionId;
   }
 };
+var CdWhilePromptActiveError = class extends Error {
+  static {
+    __name(this, "CdWhilePromptActiveError");
+  }
+  sessionId;
+  constructor(sessionId) {
+    super(
+      `Cannot change directory for session ${sessionId}: a prompt is currently active`
+    );
+    this.name = "CdWhilePromptActiveError";
+    this.sessionId = sessionId;
+  }
+};
 
 export {
+  canonicalizeWorkspace,
+  MAX_WORKSPACE_PATH_LENGTH,
   NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE,
   isNotCurrentlyGeneratingCancelError,
   SessionNotFoundError,
@@ -357,7 +387,8 @@ export {
   McpServerRestartFailedError,
   SessionBusyError,
   InvalidRewindTargetError,
-  BranchWhilePromptActiveError
+  BranchWhilePromptActiveError,
+  CdWhilePromptActiveError
 };
 /**
  * @license