@qwen-code/qwen-code 0.21.11 → 0.21.12-preview.1

package/chunks/{chunk-MCHGE3EC.js → chunk-QIN5P5BP.js}

@@ -8,16 +8,15 @@ import {
   staleArgsWarning,
   validateAuthMethod,
   writeSkillArgs
-} from "./chunk-TTB6GBJ6.js";
+} from "./chunk-VUFEW3SF.js";
 import {
   calculateCost,
-  computeSessionStats,
   diffCommand,
   filterCommandsForMode,
   findInlineMathExpressions,
   getSystemInfoFields,
   levelLabel
-} from "./chunk-DSKLWQHC.js";
+} from "./chunk-JRRZFO4A.js";
 import {
   isKittyProtocolEnabled
 } from "./chunk-NYX53SV4.js";
@@ -25,19 +24,19 @@ import {
   VSCODE_SHIFT_ENTER_SEQUENCE,
   isWaylandSession,
   writeOsc52
-} from "./chunk-TNQLAI6I.js";
+} from "./chunk-AMXMM7DH.js";
 import {
   contextCommand
-} from "./chunk-TNS2M7VL.js";
+} from "./chunk-DEVFUPC5.js";
 import {
   themeManager
 } from "./chunk-EN2J77G7.js";
-import {
-  rollbackStandaloneUpdate
-} from "./chunk-45HPDU3F.js";
 import {
   getErrorMessage as getErrorMessage2
-} from "./chunk-NM3E6GGL.js";
+} from "./chunk-T2VEHZH3.js";
+import {
+  rollbackStandaloneUpdate
+} from "./chunk-VO52SIZW.js";
 import {
   GITHUB_WORKFLOW_PATHS,
   INSIGHT_CSS,
@@ -50,7 +49,7 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-W2ITCESM.js";
+} from "./chunk-7L64FSYQ.js";
 import {
   stripUnsafeCharacters,
   toCodePoints,
@@ -66,12 +65,12 @@ import {
   isVoiceEnabled,
   readVoiceMode,
   readVoiceModel
-} from "./chunk-F4T5J34H.js";
+} from "./chunk-SZ36WFVK.js";
 import {
   getExtendedSystemInfo,
   getGitVersion,
   getNpmVersion
-} from "./chunk-AKLY5M2C.js";
+} from "./chunk-ZIS5I56G.js";
 import {
   formatDuration,
   formatTokenCount
@@ -79,7 +78,10 @@ import {
 import {
   isInlineModelOverrideAllowed,
   parseAcpModelOption
-} from "./chunk-23GFHEM3.js";
+} from "./chunk-5DDUYIY6.js";
+import {
+  getInstallationInfo
+} from "./chunk-L2O7DJIE.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getAllSettingKeys,
@@ -91,24 +93,21 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   validateSettingValue,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-4PFKN7CQ.js";
+} from "./chunk-3ZLUA4GV.js";
 import {
   getCurrentLanguage,
   setLanguageAsync,
   t
-} from "./chunk-KFCTC5IJ.js";
+} from "./chunk-6LK2QPIA.js";
 import {
   SUPPORTED_LANGUAGES,
   getSupportedLanguageIds,
   resolveSupportedLanguage
 } from "./chunk-5EJZE3FP.js";
-import {
-  getInstallationInfo
-} from "./chunk-LA3FF7RO.js";
 import {
   isFolderTrustEnabled,
   loadTrustedFolders
-} from "./chunk-YIKMBYMT.js";
+} from "./chunk-M2S67TPJ.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
@@ -119,7 +118,6 @@ import {
   EXTENSIONS_CONFIG_FILENAME,
   ExtensionManager,
   IdeClient,
-  Logger,
   QWEN_CODE_COMPANION_EXTENSION_NAME,
   SESSION_TITLE_MAX_LENGTH,
   SessionService,
@@ -145,13 +143,11 @@ import {
   flatMapTextParts,
   formatMemoryUsage,
   generateSessionRecap,
-  getArenaSystemReminder,
   getExtensionDescription,
   getExtensionDisplayName,
   getIdeInstaller,
   getInsightPrompt,
   getMCPServerPrompts,
-  getPlanModeSystemReminder,
   getProjectSummaryPrompt,
   getShellConfiguration,
   glob,
@@ -180,13 +176,16 @@ import {
   resolveSlimmingConfig,
   runForkedAgent,
   tryGenerateSessionTitle
-} from "./chunk-UIZGNLBP.js";
+} from "./chunk-INQN4KIA.js";
 import {
   external_exports
 } from "./chunk-CQ35AJ4Z.js";
 import {
   resolveModelId
-} from "./chunk-XT6TGJFD.js";
+} from "./chunk-U6LT3QBF.js";
+import {
+  APPROVAL_MODES
+} from "./chunk-6LYDH7VT.js";
 import {
   getAutoSkillCuratorStatus,
   parse,
@@ -204,28 +203,9 @@ import {
   emptyGoalSnapshot,
   projectUserTranscriptForDisplay
 } from "./chunk-SAQHDAUJ.js";
-import {
-  APPROVAL_MODES
-} from "./chunk-6LYDH7VT.js";
 import {
   resolveOpenAILogDir
-} from "./chunk-2XZWO53E.js";
-import {
-  FORK_SUBAGENT_TYPE,
-  stripStartupContext
-} from "./chunk-ZV4XVYL3.js";
-import {
-  applySkillAllowedTools,
-  buildSkillLlmContent
-} from "./chunk-K623ENWT.js";
-import {
-  openBrowserSecurely
-} from "./chunk-NAVJD2PQ.js";
-import {
-  REASONING_EFFORT_TIERS,
-  applyReasoningEffort,
-  normalizeReasoningEffort
-} from "./chunk-KM73TBQ4.js";
+} from "./chunk-6XZERB6P.js";
 import {
   COMBINED_PASS_TOLERANCE_FACTOR,
   IdeConnectionEvent,
@@ -237,21 +217,35 @@ import {
   logIdeConnection,
   queryTokenUsage,
   read,
-  recordSkillInvocation,
   uiTelemetryService
-} from "./chunk-U2JLICUY.js";
+} from "./chunk-HB6QW4LM.js";
 import {
   getAutoMemoryRoot
 } from "./chunk-732MOPEM.js";
 import {
   runSideQuery
 } from "./chunk-CTQE2NB2.js";
+import {
+  FORK_SUBAGENT_TYPE,
+  stripStartupContext
+} from "./chunk-ZV4XVYL3.js";
+import {
+  applySkillAllowedTools,
+  buildSkillLlmContent
+} from "./chunk-K623ENWT.js";
 import {
   ToolDisplayNamesMigration,
   ToolNames,
-  canonicalToolName,
-  isShellProgressData
+  canonicalToolName
 } from "./chunk-XTH2OMDS.js";
+import {
+  openBrowserSecurely
+} from "./chunk-NAVJD2PQ.js";
+import {
+  REASONING_EFFORT_TIERS,
+  applyReasoningEffort,
+  normalizeReasoningEffort
+} from "./chunk-KM73TBQ4.js";
 import {
   Storage,
   createDebugLogger,
@@ -265,7 +259,7 @@ import {
   isCpuProfileRecording,
   startCpuProfile,
   stopCpuProfile
-} from "./chunk-3LHYTQ2R.js";
+} from "./chunk-M3QYOPGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -594,9 +588,6 @@ function findSlashCommandTokens(text, commands) {
 }
 __name(findSlashCommandTokens, "findSlashCommandTokens");
 
-// packages/cli/src/nonInteractiveCliCommands.ts
-init_esbuild_shims();
-
 // packages/cli/src/services/CommandService.ts
 init_esbuild_shims();
 var debugLogger2 = createDebugLogger("CLI_COMMANDS");
@@ -2055,7 +2046,7 @@ var approvalModeCommand = {
         };
       }
     }
-    const autoModeNotices = mode === "auto" /* AUTO */ && priorMode !== "auto" /* AUTO */ && config ? await import("./useAutoAcceptIndicator-AUNRB5S7.js") : void 0;
+    const autoModeNotices = mode === "auto" /* AUTO */ && priorMode !== "auto" /* AUTO */ && config ? await import("./useAutoAcceptIndicator-3QJ7QV5R.js") : void 0;
     if (config) {
       try {
         config.setApprovalMode(mode);
@@ -6846,7 +6837,7 @@ var expandNowCommand = {
         content: t("History is already expanded in this session.")
       };
     }
-    const { expandCollapsedHistory } = await import("./resumeHistoryUtils-RR2KEVH5.js");
+    const { expandCollapsedHistory } = await import("./resumeHistoryUtils-UMC4Y3E2.js");
     const updated = expandCollapsedHistory(history);
     loadHistory(updated);
     refreshStatic();
@@ -8296,7 +8287,7 @@ var initCommand = {
         if (existing && existing.trim().length > 0) {
           if (!context.overwriteConfirmed) {
             const [{ Text }, { default: React }] = await Promise.all([
-              import("./build-GDBLPA24.js"),
+              import("./build-RZS65IIX.js"),
               import("./react-SG7JAQSZ.js")
             ]);
             return {
@@ -14117,10 +14108,10 @@ var updateCommand = {
       { performStandaloneUpdate },
       installationInfo
     ] = await Promise.all([
-      import("./updateCheck-VBRNPLS4.js"),
-      import("./processUtils-M635AD23.js"),
-      import("./standalone-update-5NN3MTYH.js"),
-      import("./installationInfo-6USRNCD2.js")
+      import("./updateCheck-3BQA7KNI.js"),
+      import("./processUtils-ILOXESNR.js"),
+      import("./standalone-update-G4BETY4B.js"),
+      import("./installationInfo-GY2OCLIS.js")
     ]);
     const { formatUpdateInstructions, getInstallationInfo: getInstallationInfo2 } = installationInfo;
     const settings = context.services.settings;
@@ -15581,46 +15572,6 @@ var SkillCommandLoader = class {
   }
 };
 
-// packages/cli/src/ui/noninteractive/nonInteractiveUi.ts
-init_esbuild_shims();
-function createNonInteractiveUI() {
-  return {
-    history: [],
-    addItem: /* @__PURE__ */ __name((_item, _timestamp) => 0, "addItem"),
-    clear: /* @__PURE__ */ __name(() => {
-    }, "clear"),
-    setDebugMessage: /* @__PURE__ */ __name((_message) => {
-    }, "setDebugMessage"),
-    loadHistory: /* @__PURE__ */ __name((_newHistory) => {
-    }, "loadHistory"),
-    refreshStatic: /* @__PURE__ */ __name(() => {
-    }, "refreshStatic"),
-    pendingItem: null,
-    setPendingItem: /* @__PURE__ */ __name((_item) => {
-    }, "setPendingItem"),
-    btwItem: null,
-    setBtwItem: /* @__PURE__ */ __name((_item) => {
-    }, "setBtwItem"),
-    cancelBtw: /* @__PURE__ */ __name(() => {
-    }, "cancelBtw"),
-    btwAbortControllerRef: { current: null },
-    isIdleRef: { current: true },
-    toggleVimEnabled: /* @__PURE__ */ __name(async () => false, "toggleVimEnabled"),
-    setGeminiMdFileCount: /* @__PURE__ */ __name((_count) => {
-    }, "setGeminiMdFileCount"),
-    reloadCommands: /* @__PURE__ */ __name(() => {
-    }, "reloadCommands"),
-    setSessionName: /* @__PURE__ */ __name(() => {
-    }, "setSessionName"),
-    extensionsUpdateState: /* @__PURE__ */ new Map(),
-    dispatchExtensionStateUpdate: /* @__PURE__ */ __name((_action) => {
-    }, "dispatchExtensionStateUpdate"),
-    addConfirmUpdateExtensionRequest: /* @__PURE__ */ __name((_request) => {
-    }, "addConfirmUpdateExtensionRequest")
-  };
-}
-__name(createNonInteractiveUI, "createNonInteractiveUI");
-
 // packages/cli/src/utils/userPromptExpansionHook.ts
 init_esbuild_shims();
 function appendUserPromptExpansionAdditionalContext(content, additionalContext) {
@@ -15649,724 +15600,6 @@ function formatUserPromptExpansionBlockedMessage(reason) {
 }
 __name(formatUserPromptExpansionBlockedMessage, "formatUserPromptExpansionBlockedMessage");
 
-// packages/cli/src/nonInteractiveCliCommands.ts
-var debugLogger19 = createDebugLogger("NON_INTERACTIVE_COMMANDS");
-function getSkillCommandName(command) {
-  return command.skillDetail?.name ?? command.name;
-}
-__name(getSkillCommandName, "getSkillCommandName");
-function handleCommandResult(result, outputHistoryItems) {
-  switch (result.type) {
-    case "submit_prompt":
-      return {
-        type: "submit_prompt",
-        content: result.content,
-        ...result.modelOverride ? { modelOverride: result.modelOverride } : {},
-        ...result.refreshContextFilesOnWrite ? { refreshContextFilesOnWrite: true } : {},
-        ...outputHistoryItems?.length ? { outputHistoryItems } : {}
-      };
-    case "message":
-      return {
-        type: "message",
-        messageType: result.messageType,
-        content: result.content,
-        ...outputHistoryItems?.length ? { outputHistoryItems } : {}
-      };
-    case "stream_messages":
-      return {
-        type: "stream_messages",
-        messages: result.messages
-      };
-    case "goal_control":
-      return {
-        type: "goal_control",
-        operation: result.operation,
-        response: result.response,
-        ...result.cause ? { cause: result.cause } : {}
-      };
-    /**
-     * Currently return types below are never generated due to the
-     * whitelist of allowed slash commands in ACP and non-interactive mode.
-     * We'll try to add more supported return types in the future.
-     */
-    case "tool":
-      return {
-        type: "unsupported",
-        reason: "Tool execution from slash commands is not supported in non-interactive mode.",
-        originalType: "tool"
-      };
-    case "quit":
-      return {
-        type: "unsupported",
-        reason: "Quit command is not supported in non-interactive mode. The process will exit naturally after completion.",
-        originalType: "quit"
-      };
-    case "dialog":
-      return {
-        type: "unsupported",
-        reason: `Dialog '${result.dialog}' cannot be opened in non-interactive mode.`,
-        originalType: "dialog"
-      };
-    case "load_history":
-      return {
-        type: "unsupported",
-        reason: "Loading history is not supported in non-interactive mode. Each invocation starts with a fresh context.",
-        originalType: "load_history"
-      };
-    case "confirm_shell_commands":
-      return {
-        type: "unsupported",
-        reason: "Shell command confirmation is not supported in non-interactive mode. Use YOLO mode or pre-approve commands.",
-        originalType: "confirm_shell_commands"
-      };
-    case "confirm_action":
-      return {
-        type: "unsupported",
-        reason: "Action confirmation is not supported in non-interactive mode. Commands requiring confirmation cannot be executed.",
-        originalType: "confirm_action"
-      };
-    default: {
-      const _exhaustive = result;
-      return {
-        type: "unsupported",
-        reason: `Unknown command result type: ${_exhaustive.type}`,
-        originalType: "unknown"
-      };
-    }
-  }
-}
-__name(handleCommandResult, "handleCommandResult");
-async function fireUserPromptExpansionHook(config, commandName, commandArgs, content, signal) {
-  if (config.getDisableAllHooks?.() || !(config.hasHooksForEvent?.("UserPromptExpansion") ?? false)) {
-    return { content };
-  }
-  const hookSystem = config.getHookSystem();
-  if (!hookSystem) {
-    return { content };
-  }
-  const output = await hookSystem.fireUserPromptExpansionEvent(
-    commandName,
-    commandArgs,
-    serializeUserPromptExpansionPrompt(content),
-    signal
-  );
-  if (!output) {
-    return { content };
-  }
-  const blockingError = output.getBlockingError();
-  if (blockingError.blocked || output.shouldStopExecution()) {
-    return {
-      blockedResult: {
-        type: "message",
-        messageType: "error",
-        content: formatUserPromptExpansionBlockedMessage(
-          blockingError.reason || output.getEffectiveReason()
-        )
-      },
-      content
-    };
-  }
-  return {
-    content: appendUserPromptExpansionAdditionalContext(
-      content,
-      output.getAdditionalContext()
-    )
-  };
-}
-__name(fireUserPromptExpansionHook, "fireUserPromptExpansionHook");
-async function registerModelInvocableCommands(commandService, config, executionMode, settings) {
-  if (!settings) {
-    return;
-  }
-  config.setModelInvocableCommandsProvider(
-    () => commandService.getModelInvocableCommands().map((cmd) => ({
-      name: cmd.name,
-      description: cmd.modelDescription ?? cmd.description
-    }))
-  );
-  config.setModelInvocableCommandsExecutor(
-    async (name, args = "") => {
-      const commands = commandService.getModelInvocableCommands();
-      const cmd = commands.find((c) => c.name === name);
-      if (!cmd?.action) return null;
-      const minimalContext = {
-        executionMode,
-        invocation: {
-          raw: args ? `/${name} ${args}` : `/${name}`,
-          name,
-          args
-        },
-        services: { config, settings, logger: null }
-      };
-      const result = await cmd.action(minimalContext, args);
-      if (!result || result.type !== "submit_prompt") return null;
-      const hookSignal = new AbortController().signal;
-      const hookResult = await fireUserPromptExpansionHook(
-        config,
-        name,
-        args,
-        result.content,
-        hookSignal
-      );
-      if (hookResult.blockedResult) {
-        return hookResult.blockedResult.type === "message" ? { error: hookResult.blockedResult.content } : null;
-      }
-      const content = hookResult.content;
-      if (typeof content === "string") return content;
-      if (Array.isArray(content)) {
-        return content.map(
-          (p) => typeof p === "string" ? p : p.text ?? ""
-        ).join("");
-      }
-      return null;
-    }
-  );
-  const skillManager = typeof config.getSkillManager === "function" ? config.getSkillManager() : null;
-  await skillManager?.notifyConfigChanged();
-}
-__name(registerModelInvocableCommands, "registerModelInvocableCommands");
-var handleSlashCommand = /* @__PURE__ */ __name(async (rawQuery, abortController, config, settings, sessionHooks) => {
-  const trimmed = rawQuery.trim();
-  if (!trimmed.startsWith("/")) {
-    return { type: "no_command" };
-  }
-  const isAcpMode = config.getExperimentalZedIntegration();
-  const isInteractive = config.isInteractive();
-  const executionMode = isAcpMode ? "acp" : isInteractive ? "interactive" : "non_interactive";
-  const allLoaders = [
-    new McpPromptLoader(config),
-    new BuiltinCommandLoader(config),
-    new BundledSkillLoader(config),
-    new SkillCommandLoader(config),
-    new SavedWorkflowLoader(config),
-    new FileCommandLoader(config)
-  ];
-  const disabledSlashCommandsRaw = config.getDisabledSlashCommands();
-  const disabledNameSet = /* @__PURE__ */ new Set();
-  for (const name of disabledSlashCommandsRaw) {
-    const trimmed2 = name.trim();
-    if (trimmed2) disabledNameSet.add(trimmed2.toLowerCase());
-  }
-  const isDisabled = /* @__PURE__ */ __name((cmd) => disabledNameSet.has(cmd.name.toLowerCase()) || (cmd.altNames ?? []).some((a) => disabledNameSet.has(a.toLowerCase())), "isDisabled");
-  const allCommandService = await CommandService.create(
-    allLoaders,
-    abortController.signal
-  );
-  const commandService = disabledNameSet.size > 0 ? await CommandService.create(
-    allLoaders,
-    abortController.signal,
-    disabledNameSet
-  ) : allCommandService;
-  await registerModelInvocableCommands(
-    commandService,
-    config,
-    executionMode,
-    settings
-  );
-  const allCommands = allCommandService.getCommands();
-  const filteredCommands = commandService.getCommandsForMode(executionMode).filter((cmd) => !isDisabled(cmd));
-  const { commandToExecute, args } = parseSlashCommand(
-    rawQuery,
-    filteredCommands
-  );
-  const stackedResult = parseStackedSlashCommands(rawQuery, filteredCommands);
-  if (stackedResult.skills.length >= 2) {
-    const combinedContent = [];
-    let firstModelOverride;
-    let refreshContextFilesOnWrite = false;
-    const onCompleteCallbacks = [];
-    const successfulSkillCommands = [];
-    for (const skill of stackedResult.skills) {
-      if (!skill.action) continue;
-      const skillContext = {
-        executionMode,
-        invocation: {
-          raw: `/${skill.name}`,
-          name: skill.name,
-          args: ""
-        },
-        services: { config, settings, logger: null }
-      };
-      const skillResult = await skill.action(skillContext, "");
-      if (skillResult?.type === "submit_prompt") {
-        combinedContent.push(skillResult.content);
-        firstModelOverride ??= skillResult.modelOverride;
-        refreshContextFilesOnWrite ||= Boolean(
-          skillResult.refreshContextFilesOnWrite
-        );
-        if (skillResult.onComplete) {
-          onCompleteCallbacks.push(skillResult.onComplete);
-        }
-      }
-      const succeeded = skillResult?.type === "submit_prompt";
-      recordSkillInvocation(config, {
-        skillName: getSkillCommandName(skill),
-        success: succeeded
-      });
-      if (succeeded) {
-        successfulSkillCommands.push(skill);
-      }
-    }
-    if (stackedResult.remainingText) {
-      combinedContent.push([{ text: stackedResult.remainingText }]);
-    }
-    const mergedContent = combinedContent.flat();
-    const hookResult = await fireUserPromptExpansionHook(
-      config,
-      stackedResult.skills.map((s) => s.name).join(" "),
-      stackedResult.remainingText,
-      mergedContent,
-      abortController.signal
-    );
-    if (hookResult.blockedResult) {
-      return hookResult.blockedResult;
-    }
-    for (const skill of successfulSkillCommands) {
-      void recordAutoSkillCommandUsage(config, skill);
-    }
-    return {
-      type: "submit_prompt",
-      content: hookResult.content,
-      ...firstModelOverride ? { modelOverride: firstModelOverride } : {},
-      ...refreshContextFilesOnWrite ? { refreshContextFilesOnWrite: true } : {},
-      ...onCompleteCallbacks.length ? {
-        onComplete: /* @__PURE__ */ __name(async () => {
-          for (const cb of onCompleteCallbacks) await cb();
-        }, "onComplete")
-      } : {}
-    };
-  }
-  if (!commandToExecute) {
-    const { commandToExecute: knownCommand } = parseSlashCommand(
-      rawQuery,
-      allCommands
-    );
-    if (knownCommand) {
-      const typedToken = rawQuery.trim().substring(1).trim().split(/\s+/)[0] ?? knownCommand.name;
-      if (isDisabled(knownCommand)) {
-        return {
-          type: "unsupported",
-          reason: t(
-            'The command "/{{command}}" is disabled by the current configuration.',
-            { command: typedToken }
-          ),
-          originalType: "filtered_command"
-        };
-      }
-      return {
-        type: "unsupported",
-        reason: t('The command "/{{command}}" is not supported in this mode.', {
-          command: typedToken
-        }),
-        originalType: "filtered_command"
-      };
-    }
-    return { type: "no_command" };
-  }
-  if (!commandToExecute.action) {
-    return { type: "no_command" };
-  }
-  const sessionStats = {
-    sessionId: config?.getSessionId(),
-    sessionStartTime: /* @__PURE__ */ new Date(),
-    metrics: config ? uiTelemetryService.getMetricsForSession(config.getSessionId()) : uiTelemetryService.getMetrics(),
-    lastPromptTokenCount: 0,
-    promptCount: 1
-  };
-  const logger3 = new Logger(config?.getSessionId() || "", config?.storage);
-  const outputHistoryItems = [];
-  const ui = createNonInteractiveUI();
-  ui.addItem = (item) => {
-    outputHistoryItems.push(item);
-    return 0;
-  };
-  const context = {
-    executionMode,
-    services: {
-      config,
-      settings,
-      logger: logger3
-    },
-    ui,
-    session: {
-      stats: sessionStats,
-      sessionShellAllowlist: /* @__PURE__ */ new Set(),
-      ...sessionHooks?.startNewSession ? { startNewSession: sessionHooks.startNewSession } : {}
-    },
-    invocation: {
-      raw: trimmed,
-      name: commandToExecute.name,
-      args
-    }
-  };
-  const isSkillCommand = commandToExecute.kind === "skill" /* SKILL */;
-  let skillInvocationRecorded = false;
-  const recordSkillCommandInvocation = /* @__PURE__ */ __name((success) => {
-    if (!isSkillCommand || skillInvocationRecorded) {
-      return;
-    }
-    recordSkillInvocation(config, {
-      skillName: getSkillCommandName(commandToExecute),
-      success
-    });
-    skillInvocationRecorded = true;
-  }, "recordSkillCommandInvocation");
-  let result;
-  try {
-    result = await commandToExecute.action(context, args);
-  } catch (error) {
-    recordSkillCommandInvocation(false);
-    throw error;
-  }
-  if (!result) {
-    return {
-      type: "message",
-      messageType: "info",
-      content: "Command executed successfully."
-    };
-  }
-  if (result.type === "submit_prompt") {
-    let hookResult;
-    try {
-      hookResult = await fireUserPromptExpansionHook(
-        config,
-        commandToExecute.name,
-        args,
-        result.content,
-        abortController.signal
-      );
-    } catch (error) {
-      recordSkillCommandInvocation(false);
-      throw error;
-    }
-    if (hookResult.blockedResult) {
-      recordSkillCommandInvocation(false);
-      return hookResult.blockedResult;
-    }
-    recordSkillCommandInvocation(true);
-    void recordAutoSkillCommandUsage(config, commandToExecute);
-    return handleCommandResult(
-      { ...result, content: hookResult.content },
-      outputHistoryItems
-    );
-  }
-  return handleCommandResult(result, outputHistoryItems);
-}, "handleSlashCommand");
-var getAvailableCommands = /* @__PURE__ */ __name(async (config, abortSignal, mode = "acp", settings) => {
-  try {
-    const loaders = [
-      new McpPromptLoader(config),
-      new BuiltinCommandLoader(config),
-      new BundledSkillLoader(config),
-      new SkillCommandLoader(config),
-      new SavedWorkflowLoader(config),
-      new FileCommandLoader(config)
-    ];
-    const disabledSlashCommands = config.getDisabledSlashCommands();
-    const commandService = await CommandService.create(
-      loaders,
-      abortSignal,
-      disabledSlashCommands.length > 0 ? new Set(disabledSlashCommands) : void 0
-    );
-    await registerModelInvocableCommands(
-      commandService,
-      config,
-      mode,
-      settings
-    );
-    return commandService.getCommandsForMode(mode);
-  } catch (error) {
-    debugLogger19.error("Error loading available commands:", error);
-    return [];
-  }
-}, "getAvailableCommands");
-
-// packages/cli/src/utils/nonInteractiveHelpers.ts
-init_esbuild_shims();
-var debugLogger20 = createDebugLogger("NON_INTERACTIVE");
-function normalizePartList(parts) {
-  if (!parts) {
-    return [];
-  }
-  if (typeof parts === "string") {
-    return [{ text: parts }];
-  }
-  if (Array.isArray(parts)) {
-    return parts.map(
-      (part) => typeof part === "string" ? { text: part } : part
-    );
-  }
-  return [parts];
-}
-__name(normalizePartList, "normalizePartList");
-function extractPartsFromUserMessage(message2) {
-  if (!message2) {
-    return null;
-  }
-  const content = message2.message?.content;
-  if (typeof content === "string") {
-    return content;
-  }
-  if (Array.isArray(content)) {
-    const parts = [];
-    for (const block of content) {
-      if (!block || typeof block !== "object" || !("type" in block)) {
-        continue;
-      }
-      if (block.type === "text" && "text" in block && block.text) {
-        parts.push({ text: block.text });
-      } else {
-        parts.push({ text: JSON.stringify(block) });
-      }
-    }
-    return parts.length > 0 ? parts : null;
-  }
-  return null;
-}
-__name(extractPartsFromUserMessage, "extractPartsFromUserMessage");
-function computeUsageFromMetrics(metrics) {
-  const stats = computeSessionStats(metrics);
-  const { models } = metrics;
-  const totalOutputTokens = Object.values(models).reduce(
-    (acc, model) => acc + model.tokens.candidates,
-    0
-  );
-  const totalTokens = Object.values(models).reduce(
-    (acc, model) => acc + model.tokens.total,
-    0
-  );
-  const usage2 = {
-    input_tokens: stats.totalPromptTokens,
-    output_tokens: totalOutputTokens,
-    cache_read_input_tokens: stats.totalCachedTokens
-  };
-  if (totalTokens > 0) {
-    usage2.total_tokens = totalTokens;
-  }
-  return usage2;
-}
-__name(computeUsageFromMetrics, "computeUsageFromMetrics");
-function buildInitialSystemReminders(config) {
-  const reminders = [];
-  if (config.getApprovalMode() === "plan" /* PLAN */) {
-    reminders.push({ text: getPlanModeSystemReminder(config.getSdkMode?.()) });
-  }
-  const arenaManager = config.getArenaManager?.();
-  if (arenaManager) {
-    try {
-      const sessionDir = arenaManager.getArenaSessionDir();
-      const configPath = `${sessionDir}/config.json`;
-      reminders.push({ text: getArenaSystemReminder(configPath) });
-    } catch {
-    }
-  }
-  return reminders;
-}
-__name(buildInitialSystemReminders, "buildInitialSystemReminders");
-function insertAfterFunctionResponses(parts, additions) {
-  const firstNonFunctionResponse = parts.findIndex(
-    (part) => !part.functionResponse
-  );
-  const insertAt = firstNonFunctionResponse === -1 ? parts.length : firstNonFunctionResponse;
-  return [...parts.slice(0, insertAt), ...additions, ...parts.slice(insertAt)];
-}
-__name(insertAfterFunctionResponses, "insertAfterFunctionResponses");
-async function loadSlashCommandNames(config) {
-  const controller = new AbortController();
-  try {
-    const commands = await getAvailableCommands(
-      config,
-      controller.signal,
-      "non_interactive"
-    );
-    return commands.map((cmd) => cmd.name).sort();
-  } catch (error) {
-    debugLogger20.error(
-      "[buildSystemMessage] Failed to load slash commands:",
-      error
-    );
-    return [];
-  } finally {
-    controller.abort();
-  }
-}
-__name(loadSlashCommandNames, "loadSlashCommandNames");
-async function buildSystemMessage(config, sessionId, permissionMode) {
-  const toolRegistry = config.getToolRegistry();
-  const tools = toolRegistry ? toolRegistry.getAllToolNames() : [];
-  const mcpServers = config.getMcpServers();
-  const mcpServerList = mcpServers ? Object.keys(mcpServers).map((name) => ({
-    name,
-    status: getMCPServerStatus(name)
-  })) : [];
-  const slashCommands = await loadSlashCommandNames(config);
-  let agentNames = [];
-  try {
-    const subagentManager = config.getSubagentManager();
-    const subagents = await subagentManager.listSubagents();
-    agentNames = subagents.map((subagent) => subagent.name);
-  } catch (error) {
-    debugLogger20.error("[buildSystemMessage] Failed to load subagents:", error);
-  }
-  const systemMessage = {
-    type: "system",
-    subtype: "init",
-    uuid: sessionId,
-    session_id: sessionId,
-    cwd: config.getTargetDir(),
-    tools,
-    mcp_servers: mcpServerList,
-    model: config.getModel(),
-    permission_mode: permissionMode,
-    slash_commands: slashCommands,
-    qwen_code_version: config.getCliVersion() || "unknown",
-    agents: agentNames
-  };
-  return systemMessage;
-}
-__name(buildSystemMessage, "buildSystemMessage");
-function isMcpToolProgressData(output) {
-  return typeof output === "object" && output !== null && "type" in output && output.type === "mcp_tool_progress";
-}
-__name(isMcpToolProgressData, "isMcpToolProgressData");
-function createToolProgressHandler(request, adapter) {
-  const handler = /* @__PURE__ */ __name((_callId, output) => {
-    if (isMcpToolProgressData(output) || isShellProgressData(output)) {
-      adapter.emitToolProgress(request, output);
-    }
-  }, "handler");
-  return { handler };
-}
-__name(createToolProgressHandler, "createToolProgressHandler");
-function createAgentToolProgressHandler(config, agentToolCallId, adapter) {
-  const previousTaskStates = /* @__PURE__ */ new Map();
-  const emittedToolUseIds = /* @__PURE__ */ new Set();
-  const emittedToolResultIds = /* @__PURE__ */ new Set();
-  const buildRequest = /* @__PURE__ */ __name((toolCall) => ({
-    callId: toolCall.callId,
-    name: toolCall.name,
-    args: toolCall.args || {},
-    isClientInitiated: true,
-    prompt_id: "",
-    response_id: void 0
-  }), "buildRequest");
-  const buildResponse = /* @__PURE__ */ __name((toolCall) => ({
-    callId: toolCall.callId,
-    error: toolCall.status === "failed" ? new Error(toolCall.error || "Tool execution failed") : void 0,
-    errorType: toolCall.status === "failed" ? "execution_failed" /* EXECUTION_FAILED */ : void 0,
-    resultDisplay: toolCall.resultDisplay,
-    responseParts: toolCall.responseParts || []
-  }), "buildResponse");
-  const hasResultContent = /* @__PURE__ */ __name((toolCall) => {
-    if (typeof toolCall.resultDisplay === "string" && toolCall.resultDisplay.trim().length > 0) {
-      return true;
-    }
-    if (toolCall.responseParts && toolCall.responseParts.length > 0) {
-      return true;
-    }
-    return toolCall.status === "failed";
-  }, "hasResultContent");
-  const emitToolUseIfNeeded = /* @__PURE__ */ __name((toolCall, fallbackStatus) => {
-    if (emittedToolUseIds.has(toolCall.callId)) {
-      return;
-    }
-    const toolCallToEmit = fallbackStatus ? {
-      ...toolCall,
-      status: fallbackStatus
-    } : toolCall;
-    if (toolCallToEmit.status === "executing" || toolCallToEmit.status === "awaiting_approval") {
-      if (adapter.processSubagentToolCall) {
-        adapter.processSubagentToolCall(toolCallToEmit, agentToolCallId);
-        emittedToolUseIds.add(toolCall.callId);
-      }
-    }
-  }, "emitToolUseIfNeeded");
-  const emitToolResultIfNeeded = /* @__PURE__ */ __name((toolCall) => {
-    if (emittedToolResultIds.has(toolCall.callId)) {
-      return;
-    }
-    if (!hasResultContent(toolCall)) {
-      return;
-    }
-    emittedToolResultIds.add(toolCall.callId);
-    const request = buildRequest(toolCall);
-    const response = buildResponse(toolCall);
-    if ("emitToolResult" in adapter && typeof adapter.emitToolResult === "function") {
-      adapter.emitToolResult(request, response, agentToolCallId);
-    } else {
-      adapter.emitToolResult(request, response);
-    }
-  }, "emitToolResultIfNeeded");
-  const processToolCall = /* @__PURE__ */ __name((toolCall, previousCall) => {
-    const isCompleted = toolCall.status === "success" || toolCall.status === "failed";
-    const isExecuting = toolCall.status === "executing" || toolCall.status === "awaiting_approval";
-    const wasExecuting = previousCall && (previousCall.status === "executing" || previousCall.status === "awaiting_approval");
-    if (isExecuting) {
-      emitToolUseIfNeeded(toolCall);
-    } else if (isCompleted && !emittedToolUseIds.has(toolCall.callId)) {
-      emitToolUseIfNeeded(toolCall, "executing");
-    } else if (wasExecuting && isCompleted) {
-      emitToolUseIfNeeded(toolCall, "executing");
-    }
-    if (isCompleted) {
-      emitToolResultIfNeeded(toolCall);
-    }
-  }, "processToolCall");
-  const outputUpdateHandler = /* @__PURE__ */ __name((callId, outputChunk) => {
-    if (typeof outputChunk === "object" && outputChunk !== null && "type" in outputChunk && outputChunk.type === "task_execution") {
-      const taskDisplay = outputChunk;
-      const previous = previousTaskStates.get(callId);
-      if (!adapter.processSubagentToolCall || !adapter.emitSubagentErrorResult) {
-        previousTaskStates.set(callId, taskDisplay);
-        return;
-      }
-      if (taskDisplay.toolCalls) {
-        if (!previous || !previous.toolCalls) {
-          for (const toolCall of taskDisplay.toolCalls) {
-            processToolCall(toolCall);
-          }
-        } else {
-          for (const toolCall of taskDisplay.toolCalls) {
-            const previousCall = previous.toolCalls.find(
-              (tc) => tc.callId === toolCall.callId
-            );
-            processToolCall(toolCall, previousCall);
-          }
-        }
-      }
-      if (taskDisplay.status === "failed" || taskDisplay.status === "cancelled") {
-        const previousStatus = previous?.status;
-        if (previousStatus !== "failed" && previousStatus !== "cancelled" && previousStatus !== void 0) {
-          const errorMessage2 = taskDisplay.terminateReason || (taskDisplay.status === "cancelled" ? "Task was cancelled" : "Task execution failed");
-          adapter.emitSubagentErrorResult(errorMessage2, 0, agentToolCallId);
-        }
-      }
-      if (!previous && taskDisplay.taskPrompt && !config.isInteractive() && (config.getOutputFormat() === "json" /* JSON */ || config.getOutputFormat() === "stream-json" /* STREAM_JSON */)) {
-        adapter.emitUserMessage(
-          [{ text: taskDisplay.taskPrompt }],
-          agentToolCallId
-        );
-      }
-      previousTaskStates.set(callId, taskDisplay);
-    }
-  }, "outputUpdateHandler");
-  return {
-    handler: outputUpdateHandler
-  };
-}
-__name(createAgentToolProgressHandler, "createAgentToolProgressHandler");
-function functionResponsePartsToString(parts) {
-  return parts.map((part) => {
-    if ("functionResponse" in part) {
-      const response = part.functionResponse?.response;
-      const content = response?.["output"] ?? response?.["error"] ?? "";
-      return content;
-    }
-    return JSON.stringify(part);
-  }).join("");
-}
-__name(functionResponsePartsToString, "functionResponsePartsToString");
-
 export {
   MAX_STACKED_SKILLS,
   isStackedSkillCompletableCommand,
@@ -16408,18 +15641,7 @@ export {
   SkillCommandLoader,
   appendUserPromptExpansionAdditionalContext,
   serializeUserPromptExpansionPrompt,
-  formatUserPromptExpansionBlockedMessage,
-  handleSlashCommand,
-  getAvailableCommands,
-  normalizePartList,
-  extractPartsFromUserMessage,
-  computeUsageFromMetrics,
-  buildInitialSystemReminders,
-  insertAfterFunctionResponses,
-  buildSystemMessage,
-  createToolProgressHandler,
-  createAgentToolProgressHandler,
-  functionResponsePartsToString
+  formatUserPromptExpansionBlockedMessage
 };
 /**
  * @license