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

package/chunks/chunk-5PLOQW7H.js

@@ -1,830 +0,0 @@
-// Force strict mode and setup for ESM
-"use strict";
-import {
-  BuiltinCommandLoader,
-  BundledSkillLoader,
-  CommandService,
-  FileCommandLoader,
-  McpPromptLoader,
-  SavedWorkflowLoader,
-  SkillCommandLoader,
-  appendUserPromptExpansionAdditionalContext,
-  formatUserPromptExpansionBlockedMessage,
-  parseSlashCommand,
-  parseStackedSlashCommands,
-  recordAutoSkillCommandUsage,
-  serializeUserPromptExpansionPrompt
-} from "./chunk-N4LVA3S6.js";
-import {
-  computeSessionStats
-} from "./chunk-DGNQ5AFX.js";
-import {
-  t
-} from "./chunk-I3UEXUWJ.js";
-import {
-  Logger,
-  getArenaSystemReminder,
-  getPlanModeSystemReminder
-} from "./chunk-T7YMWGFY.js";
-import {
-  getMCPServerStatus,
-  recordSkillInvocation,
-  uiTelemetryService
-} from "./chunk-UAAWNTOC.js";
-import {
-  isShellProgressData
-} from "./chunk-ZRT36RSF.js";
-import {
-  createDebugLogger
-} from "./chunk-YMB77M76.js";
-import {
-  init_esbuild_shims
-} from "./chunk-5O2XNYP6.js";
-import {
-  __name
-} from "./chunk-J2S4EL5Y.js";
-
-// packages/cli/src/nonInteractiveCliCommands.ts
-init_esbuild_shims();
-
-// 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/nonInteractiveCliCommands.ts
-var debugLogger = 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 logger = 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
-    },
-    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) {
-    debugLogger.error("Error loading available commands:", error);
-    return [];
-  }
-}, "getAvailableCommands");
-
-// packages/cli/src/utils/nonInteractiveHelpers.ts
-init_esbuild_shims();
-var debugLogger2 = 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(message) {
-  if (!message) {
-    return null;
-  }
-  const content = message.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 usage = {
-    input_tokens: stats.totalPromptTokens,
-    output_tokens: totalOutputTokens,
-    cache_read_input_tokens: stats.totalCachedTokens
-  };
-  if (totalTokens > 0) {
-    usage.total_tokens = totalTokens;
-  }
-  return usage;
-}
-__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) {
-    debugLogger2.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) {
-    debugLogger2.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 errorMessage = taskDisplay.terminateReason || (taskDisplay.status === "cancelled" ? "Task was cancelled" : "Task execution failed");
-          adapter.emitSubagentErrorResult(errorMessage, 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 {
-  handleSlashCommand,
-  getAvailableCommands,
-  normalizePartList,
-  extractPartsFromUserMessage,
-  computeUsageFromMetrics,
-  buildInitialSystemReminders,
-  insertAfterFunctionResponses,
-  buildSystemMessage,
-  createToolProgressHandler,
-  createAgentToolProgressHandler,
-  functionResponsePartsToString
-};
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */