@qwen-code/qwen-code 0.21.12-preview.5 → 0.21.13

package/chunks/{chunk-N4LVA3S6.js → chunk-NNHNLJ2X.js}

@@ -1,5 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  contextCommand
+} from "./chunk-N5YPT6PH.js";
 import {
   ExtensionRefreshState,
   clearSkillArgs,
@@ -8,15 +11,20 @@ import {
   staleArgsWarning,
   validateAuthMethod,
   writeSkillArgs
-} from "./chunk-Q7VJUIIB.js";
+} from "./chunk-IGGGG5CX.js";
 import {
   calculateCost,
+  computeSessionStats,
   diffCommand,
   filterCommandsForMode,
   findInlineMathExpressions,
   getSystemInfoFields,
   levelLabel
-} from "./chunk-DGNQ5AFX.js";
+} from "./chunk-O4D7SPJN.js";
+import {
+  formatDuration,
+  formatTokenCount
+} from "./chunk-3SH53ANB.js";
 import {
   isKittyProtocolEnabled
 } from "./chunk-NYX53SV4.js";
@@ -24,19 +32,16 @@ import {
   VSCODE_SHIFT_ENTER_SEQUENCE,
   isWaylandSession,
   writeOsc52
-} from "./chunk-UPUAGRKY.js";
-import {
-  contextCommand
-} from "./chunk-E7XJWIWC.js";
+} from "./chunk-DXIBNLBZ.js";
 import {
   themeManager
-} from "./chunk-6LDLDK6E.js";
+} from "./chunk-2M55OBEB.js";
 import {
   getErrorMessage as getErrorMessage2
-} from "./chunk-HOXEJHJQ.js";
+} from "./chunk-JUEPY766.js";
 import {
   rollbackStandaloneUpdate
-} from "./chunk-72SKJ3E7.js";
+} from "./chunk-NEFOOD54.js";
 import {
   GITHUB_WORKFLOW_PATHS,
   INSIGHT_CSS,
@@ -49,7 +54,7 @@ import {
   toJson,
   toJsonl,
   toMarkdown
-} from "./chunk-LYRA6ZTI.js";
+} from "./chunk-RLKC46YT.js";
 import {
   stripUnsafeCharacters,
   toCodePoints,
@@ -65,23 +70,19 @@ import {
   isVoiceEnabled,
   readVoiceMode,
   readVoiceModel
-} from "./chunk-N2G4RA77.js";
+} from "./chunk-QIH2HAEN.js";
 import {
   getExtendedSystemInfo,
   getGitVersion,
   getNpmVersion
-} from "./chunk-VAPNUDD5.js";
-import {
-  formatDuration,
-  formatTokenCount
-} from "./chunk-3SH53ANB.js";
+} from "./chunk-XHRY7BXD.js";
 import {
   isInlineModelOverrideAllowed,
   parseAcpModelOption
-} from "./chunk-7ATQGA6V.js";
+} from "./chunk-ZYYTZUI2.js";
 import {
   getInstallationInfo
-} from "./chunk-YMIQ24FR.js";
+} from "./chunk-BKPPWD33.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getAllSettingKeys,
@@ -93,12 +94,12 @@ import {
   resolveOutputLanguageOrPreserveAuto,
   validateSettingValue,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-YCGXJ4Q3.js";
+} from "./chunk-A267JX7H.js";
 import {
   getCurrentLanguage,
   setLanguageAsync,
   t
-} from "./chunk-I3UEXUWJ.js";
+} from "./chunk-HUTNYWBG.js";
 import {
   SUPPORTED_LANGUAGES,
   getSupportedLanguageIds,
@@ -107,7 +108,7 @@ import {
 import {
   isFolderTrustEnabled,
   loadTrustedFolders
-} from "./chunk-VE2UV7IN.js";
+} from "./chunk-IWPYVAO2.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
@@ -118,6 +119,7 @@ import {
   EXTENSIONS_CONFIG_FILENAME,
   ExtensionManager,
   IdeClient,
+  Logger,
   QWEN_CODE_COMPANION_EXTENSION_NAME,
   SESSION_TITLE_MAX_LENGTH,
   SessionService,
@@ -143,11 +145,13 @@ import {
   flatMapTextParts,
   formatMemoryUsage,
   generateSessionRecap,
+  getArenaSystemReminder,
   getExtensionDescription,
   getExtensionDisplayName,
   getIdeInstaller,
   getInsightPrompt,
   getMCPServerPrompts,
+  getPlanModeSystemReminder,
   getProjectSummaryPrompt,
   getShellConfiguration,
   glob,
@@ -163,7 +167,6 @@ import {
   listWorkflowSnapshots,
   loadServerHierarchicalMemory,
   normalizeClaudeMcpServer,
-  normalizeContent,
   normalizeSkillPriority,
   parseInstallSource,
   parseLearnVideoInput,
@@ -171,21 +174,20 @@ import {
   partToString,
   persistSessionUsage,
   readPathFromWorkspace,
-  redactUrlCredentials,
   require_toml,
   resolveSlimmingConfig,
   runForkedAgent,
   tryGenerateSessionTitle
-} from "./chunk-T7YMWGFY.js";
+} from "./chunk-4S5337WV.js";
 import {
   external_exports
 } from "./chunk-CQ35AJ4Z.js";
 import {
   resolveModelId
-} from "./chunk-OZTGLK53.js";
+} from "./chunk-5EYKMUUY.js";
 import {
   APPROVAL_MODES
-} from "./chunk-SNHBRO4C.js";
+} from "./chunk-RWDNJBWN.js";
 import {
   getAutoSkillCuratorStatus,
   parse,
@@ -193,19 +195,35 @@ import {
   restoreArchivedAutoSkill,
   runAutoSkillCurator,
   setAutoSkillPinned
-} from "./chunk-KTWUFHS4.js";
+} from "./chunk-25EYDK42.js";
 import {
   HookEventName,
   sanitizeUserPromptExpansionAdditionalContext
-} from "./chunk-2ASWIM4A.js";
+} from "./chunk-MIPFDQAF.js";
 import {
   GoalPersistenceUnavailableError,
   emptyGoalSnapshot,
   projectUserTranscriptForDisplay
-} from "./chunk-B66LYK4B.js";
+} from "./chunk-OMLJNPBE.js";
 import {
   resolveOpenAILogDir
-} from "./chunk-VPZMLGD3.js";
+} from "./chunk-OXCMMLED.js";
+import {
+  FORK_SUBAGENT_TYPE,
+  stripStartupContext
+} from "./chunk-SG7ZP5PG.js";
+import {
+  applySkillAllowedTools,
+  buildSkillLlmContent
+} from "./chunk-K623ENWT.js";
+import {
+  openBrowserSecurely
+} from "./chunk-NAVJD2PQ.js";
+import {
+  REASONING_EFFORT_TIERS,
+  applyReasoningEffort,
+  normalizeReasoningEffort
+} from "./chunk-KM73TBQ4.js";
 import {
   COMBINED_PASS_TOLERANCE_FACTOR,
   IdeConnectionEvent,
@@ -217,35 +235,25 @@ import {
   logIdeConnection,
   queryTokenUsage,
   read,
+  recordSkillInvocation,
   uiTelemetryService
-} from "./chunk-UAAWNTOC.js";
+} from "./chunk-RVOJ2FBP.js";
 import {
   getAutoMemoryRoot
-} from "./chunk-6OJDN5ZT.js";
+} from "./chunk-CHHABXPE.js";
 import {
   runSideQuery
-} from "./chunk-JRTJEGSP.js";
-import {
-  FORK_SUBAGENT_TYPE,
-  stripStartupContext
-} from "./chunk-TROB4PZY.js";
-import {
-  applySkillAllowedTools,
-  buildSkillLlmContent
-} from "./chunk-K623ENWT.js";
+} from "./chunk-MA2HEDVP.js";
 import {
   ToolDisplayNamesMigration,
   ToolNames,
-  canonicalToolName
-} from "./chunk-ZRT36RSF.js";
-import {
-  openBrowserSecurely
-} from "./chunk-NAVJD2PQ.js";
+  canonicalToolName,
+  isShellProgressData
+} from "./chunk-6HY6IF3Z.js";
 import {
-  REASONING_EFFORT_TIERS,
-  applyReasoningEffort,
-  normalizeReasoningEffort
-} from "./chunk-KM73TBQ4.js";
+  normalizeContent,
+  redactUrlCredentials
+} from "./chunk-EL5SXY3T.js";
 import {
   Storage,
   createDebugLogger,
@@ -254,12 +262,12 @@ import {
   isSubpath,
   resolvePath,
   updateSymlink
-} from "./chunk-YMB77M76.js";
+} from "./chunk-BUQDLC2G.js";
 import {
   isCpuProfileRecording,
   startCpuProfile,
   stopCpuProfile
-} from "./chunk-RIDUB2GC.js";
+} from "./chunk-AW4TRXOC.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -588,6 +596,9 @@ 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");
@@ -2046,7 +2057,7 @@ var approvalModeCommand = {
         };
       }
     }
-    const autoModeNotices = mode === "auto" /* AUTO */ && priorMode !== "auto" /* AUTO */ && config ? await import("./useAutoAcceptIndicator-HPG4UFIZ.js") : void 0;
+    const autoModeNotices = mode === "auto" /* AUTO */ && priorMode !== "auto" /* AUTO */ && config ? await import("./useAutoAcceptIndicator-C7BEICBF.js") : void 0;
     if (config) {
       try {
         config.setApprovalMode(mode);
@@ -6837,7 +6848,7 @@ var expandNowCommand = {
         content: t("History is already expanded in this session.")
       };
     }
-    const { expandCollapsedHistory } = await import("./resumeHistoryUtils-UZ7GHPNY.js");
+    const { expandCollapsedHistory } = await import("./resumeHistoryUtils-EVG3WYK2.js");
     const updated = expandCollapsedHistory(history);
     loadHistory(updated);
     refreshStatic();
@@ -8287,7 +8298,7 @@ var initCommand = {
         if (existing && existing.trim().length > 0) {
           if (!context.overwriteConfirmed) {
             const [{ Text }, { default: React }] = await Promise.all([
-              import("./build-RZS65IIX.js"),
+              import("./build-GDBLPA24.js"),
               import("./react-SG7JAQSZ.js")
             ]);
             return {
@@ -14108,10 +14119,10 @@ var updateCommand = {
       { performStandaloneUpdate },
       installationInfo
     ] = await Promise.all([
-      import("./updateCheck-SMMJ27GG.js"),
-      import("./processUtils-ZEIMIVPX.js"),
-      import("./standalone-update-Y52CWCGG.js"),
-      import("./installationInfo-G3PDBWG2.js")
+      import("./updateCheck-W4Y2GFSD.js"),
+      import("./processUtils-WDA2MJFD.js"),
+      import("./standalone-update-IFM53PE7.js"),
+      import("./installationInfo-4I5FXNMH.js")
     ]);
     const { formatUpdateInstructions, getInstallationInfo: getInstallationInfo2 } = installationInfo;
     const settings = context.services.settings;
@@ -15572,6 +15583,46 @@ 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) {
@@ -15600,6 +15651,724 @@ 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,
@@ -15641,7 +16410,18 @@ export {
   SkillCommandLoader,
   appendUserPromptExpansionAdditionalContext,
   serializeUserPromptExpansionPrompt,
-  formatUserPromptExpansionBlockedMessage
+  formatUserPromptExpansionBlockedMessage,
+  handleSlashCommand,
+  getAvailableCommands,
+  normalizePartList,
+  extractPartsFromUserMessage,
+  computeUsageFromMetrics,
+  buildInitialSystemReminders,
+  insertAfterFunctionResponses,
+  buildSystemMessage,
+  createToolProgressHandler,
+  createAgentToolProgressHandler,
+  functionResponsePartsToString
 };
 /**
  * @license