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

package/chunks/chunk-T5ZFG4CI.js

@@ -0,0 +1,830 @@
+// 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-QIN5P5BP.js";
+import {
+  computeSessionStats
+} from "./chunk-JRRZFO4A.js";
+import {
+  t
+} from "./chunk-6LK2QPIA.js";
+import {
+  Logger,
+  getArenaSystemReminder,
+  getPlanModeSystemReminder
+} from "./chunk-INQN4KIA.js";
+import {
+  getMCPServerStatus,
+  recordSkillInvocation,
+  uiTelemetryService
+} from "./chunk-HB6QW4LM.js";
+import {
+  isShellProgressData
+} from "./chunk-XTH2OMDS.js";
+import {
+  createDebugLogger
+} from "./chunk-MPBRV3UU.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
+ */