pybao-cli 1.5.7 → 1.5.9

package/dist/chunk-JRMAK4PK.js

@@ -0,0 +1,926 @@
+import { createRequire as __pybCreateRequire } from "node:module";
+const require = __pybCreateRequire(import.meta.url);
+
+// src/utils/messages/core.ts
+import { createHash, randomUUID } from "crypto";
+import { last, memoize } from "lodash-es";
+
+// src/services/ai/llmConstants.ts
+var API_ERROR_MESSAGE_PREFIX = "API Error";
+var PROMPT_TOO_LONG_ERROR_MESSAGE = "Prompt is too long";
+var CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE = "Credit balance is too low";
+var INVALID_API_KEY_ERROR_MESSAGE = "Invalid API key \xB7 Please run /login";
+var NO_CONTENT_MESSAGE = "(no content)";
+var MAIN_QUERY_TEMPERATURE = 1;
+
+// src/services/telemetry/eventBus.ts
+var listeners = /* @__PURE__ */ new Map();
+function registerTelemetryListener(listenerId, listener) {
+  listeners.set(listenerId, listener);
+}
+function emitTelemetryEvent(event) {
+  for (const listener of listeners.values()) {
+    listener(event);
+  }
+}
+
+// src/utils/session/autoCompactMetrics.ts
+function safeDivide(numerator, denominator) {
+  if (denominator <= 0) return 0;
+  return numerator / denominator;
+}
+function computeAutoCompactMetrics(events) {
+  const failedEvents = events.filter((event) => event.phase === "AUTO_COMPACT_FAILED");
+  const retryEvents = events.filter((event) => event.phase === "AUTO_COMPACT_RETRY");
+  const fallbackEvents = events.filter((event) => event.phase === "AUTO_COMPACT_FALLBACK");
+  const invalidShapeFailures = failedEvents.filter(
+    (event) => event.data?.failureType === "invalid_content_shape"
+  ).length;
+  const compact_invalid_shape_rate = safeDivide(
+    invalidShapeFailures,
+    failedEvents.length
+  );
+  const retrySuccessSignals = fallbackEvents.length;
+  const compact_retry_success_rate = safeDivide(
+    retrySuccessSignals,
+    retryEvents.length + fallbackEvents.length
+  );
+  const transformAppliedEvents = events.filter(
+    (event) => event.phase === "MESSAGE_TRANSFORM_APPLIED"
+  );
+  const thinkingFirstCount = transformAppliedEvents.filter((event) => {
+    const stats = event.data?.outputBlockStats || {};
+    const thinking = Number(stats.thinking ?? 0);
+    const text = Number(stats.text ?? 0);
+    return thinking > 0 && text > 0;
+  }).length;
+  const thinking_first_ratio = safeDivide(
+    thinkingFirstCount,
+    transformAppliedEvents.length
+  );
+  const crossReplayTagged = events.filter(
+    (event) => event.phase === "AUTO_COMPACT_FAILED" || event.phase === "AUTO_COMPACT_RETRY" || event.phase === "AUTO_COMPACT_FALLBACK"
+  );
+  const crossReplayErrors = crossReplayTagged.filter(
+    (event) => event.data?.crossModelReplay === true && event.phase === "AUTO_COMPACT_FAILED"
+  ).length;
+  const crossReplayTotal = crossReplayTagged.filter(
+    (event) => event.data?.crossModelReplay === true
+  ).length;
+  const cross_model_replay_error_rate = safeDivide(
+    crossReplayErrors,
+    crossReplayTotal
+  );
+  const sessionTypedPathEvents = events.filter(
+    (event) => event.phase === "SESSION_TYPED_PATH_APPLIED"
+  );
+  const sessionFallbackEvents = events.filter(
+    (event) => event.phase === "SESSION_CANONICAL_FALLBACK_APPLIED"
+  );
+  const sessionTypedConsistencyFailedEvents = events.filter(
+    (event) => event.phase === "SESSION_TYPED_PATH_CONSISTENCY_FAILED"
+  );
+  const typedPathDecisionEventsCount = sessionTypedPathEvents.length + sessionFallbackEvents.length + sessionTypedConsistencyFailedEvents.length;
+  const typed_primary_path_rate = sessionTypedPathEvents.length + sessionFallbackEvents.length > 0 ? safeDivide(
+    sessionTypedPathEvents.length,
+    sessionTypedPathEvents.length + sessionFallbackEvents.length
+  ) : void 0;
+  const typed_contract_fail_rate = typedPathDecisionEventsCount > 0 ? safeDivide(
+    sessionTypedConsistencyFailedEvents.length,
+    typedPathDecisionEventsCount
+  ) : void 0;
+  const recoverable_failure_rate = failedEvents.length + retryEvents.length > 0 ? safeDivide(retryEvents.length, failedEvents.length + retryEvents.length) : void 0;
+  const retry_exhausted_rate = failedEvents.length > 0 ? safeDivide(
+    failedEvents.filter(
+      (event) => Number.isFinite(Number(event.data?.attempts)) && Number(event.data?.attempts) >= 2
+    ).length,
+    failedEvents.length
+  ) : void 0;
+  const boundaryEvents = events.filter(
+    (event) => event.phase === "COMPACTION_BOUNDARY_APPLIED"
+  );
+  const compaction_boundary_hit_rate = boundaryEvents.length > 0 ? safeDivide(
+    boundaryEvents.filter((event) => event.data?.applied === true).length,
+    boundaryEvents.length
+  ) : void 0;
+  const replayOutcomeEvents = boundaryEvents.filter(
+    (event) => ["replayed_latest_user_task", "synthetic_continue_prompt"].includes(
+      String(event.data?.replayMode ?? "")
+    )
+  );
+  const overflow_replay_success_rate = replayOutcomeEvents.length > 0 ? safeDivide(
+    replayOutcomeEvents.filter(
+      (event) => event.data?.replayMode === "replayed_latest_user_task"
+    ).length,
+    replayOutcomeEvents.length
+  ) : void 0;
+  const compaction_reentry_success_rate = overflow_replay_success_rate;
+  const pruneCoverageSamples = boundaryEvents.filter(
+    (event) => typeof event.data?.pruneMarkerConsumed === "boolean"
+  );
+  const prune_marker_coverage_rate = pruneCoverageSamples.length > 0 ? safeDivide(
+    pruneCoverageSamples.filter(
+      (event) => event.data?.pruneMarkerConsumed === true
+    ).length,
+    pruneCoverageSamples.length
+  ) : void 0;
+  const indexIntegritySamples = boundaryEvents.filter(
+    (event) => event.data?.indexValidationKnown === true
+  );
+  const compacted_index_integrity_rate = indexIntegritySamples.length > 0 ? safeDivide(
+    indexIntegritySamples.filter(
+      (event) => event.data?.indexValidationValid === true
+    ).length,
+    indexIntegritySamples.length
+  ) : void 0;
+  const lifecycleEvents = events.filter(
+    (event) => event.phase === "TOOL_OUTPUT_LIFECYCLE_APPLIED"
+  );
+  const lifecycleAppliedEvents = lifecycleEvents.filter(
+    (event) => event.data?.applied !== false
+  );
+  const lifecycleAgedTotal = lifecycleAppliedEvents.reduce(
+    (sum, event) => sum + Number(event.data?.agedBlocks ?? 0),
+    0
+  );
+  const lifecycleToolResultBeforeTotal = lifecycleAppliedEvents.reduce(
+    (sum, event) => sum + Number(event.data?.totalToolResultBlocksBefore ?? 0),
+    0
+  );
+  const lifecyclePlaceholderTotal = lifecycleAppliedEvents.reduce(
+    (sum, event) => sum + Number(event.data?.l2Blocks ?? 0) + Number(event.data?.l3Blocks ?? 0),
+    0
+  );
+  const lifecycleBeforeTokensTotal = lifecycleAppliedEvents.reduce(
+    (sum, event) => sum + Number(event.data?.beforeTokens ?? 0),
+    0
+  );
+  const lifecycleTokenDeltaTotal = lifecycleAppliedEvents.reduce(
+    (sum, event) => sum + Number(event.data?.tokenDelta ?? 0),
+    0
+  );
+  const danglingDetectedTotal = lifecycleAppliedEvents.reduce(
+    (sum, event) => sum + Number(event.data?.danglingDetected ?? 0),
+    0
+  );
+  const danglingClosedTotal = lifecycleAppliedEvents.reduce(
+    (sum, event) => sum + Number(event.data?.danglingClosed ?? 0),
+    0
+  );
+  const tool_output_aging_hit_rate = lifecycleToolResultBeforeTotal > 0 ? safeDivide(lifecycleAgedTotal, lifecycleToolResultBeforeTotal) : void 0;
+  const tool_output_placeholder_hit_rate = lifecycleAgedTotal > 0 ? safeDivide(lifecyclePlaceholderTotal, lifecycleAgedTotal) : void 0;
+  const tool_output_token_reduction_rate = lifecycleBeforeTokensTotal > 0 ? safeDivide(lifecycleTokenDeltaTotal, lifecycleBeforeTokensTotal) : void 0;
+  const dangling_tool_closure_rate = danglingDetectedTotal > 0 ? safeDivide(danglingClosedTotal, danglingDetectedTotal) : void 0;
+  const status_compensation_failure_rate = danglingDetectedTotal > 0 ? safeDivide(
+    Math.max(0, danglingDetectedTotal - danglingClosedTotal),
+    danglingDetectedTotal
+  ) : void 0;
+  const lifecycleDraftEvents = events.filter(
+    (event) => event.phase === "TOOL_OUTPUT_LIFECYCLE_PRE_GATE_METRICS_DRAFT"
+  );
+  const latestLifecycleDraft = lifecycleDraftEvents.length > 0 ? lifecycleDraftEvents[lifecycleDraftEvents.length - 1] : void 0;
+  const w11_sample_pass_rate = Number.isFinite(
+    Number(latestLifecycleDraft?.data?.w11_sample_pass_rate)
+  ) ? Number(latestLifecycleDraft?.data?.w11_sample_pass_rate) : void 0;
+  const w14_sample_pass_rate = Number.isFinite(
+    Number(latestLifecycleDraft?.data?.w14_sample_pass_rate)
+  ) ? Number(latestLifecycleDraft?.data?.w14_sample_pass_rate) : void 0;
+  const postPruneNoiseSamples = lifecycleEvents.filter(
+    (event) => Number.isFinite(Number(event.data?.beforeTokens)) && Number(event.data?.beforeTokens) > 0 && Number.isFinite(Number(event.data?.afterTokens))
+  );
+  const post_prune_noise_ratio = postPruneNoiseSamples.length > 0 ? postPruneNoiseSamples.reduce((sum, event) => {
+    const before = Number(event.data?.beforeTokens);
+    const after = Number(event.data?.afterTokens);
+    return sum + Math.max(0, Math.min(1, safeDivide(after, before)));
+  }, 0) / postPruneNoiseSamples.length : void 0;
+  const sanitizerEvents = events.filter(
+    (event) => event.phase === "AUTO_COMPACT_SANITIZER_APPLIED"
+  );
+  const removedNoiseTotal = sanitizerEvents.reduce(
+    (sum, event) => sum + Number(event.data?.removedReminderTags ?? 0) + Number(event.data?.removedToolProgressTags ?? 0),
+    0
+  );
+  const changedMessagesTotal = sanitizerEvents.reduce(
+    (sum, event) => sum + Number(event.data?.changedMessages ?? 0),
+    0
+  );
+  const noise_ratio_after_compaction = changedMessagesTotal > 0 ? Math.max(
+    0,
+    Math.min(1, 1 - safeDivide(removedNoiseTotal, changedMessagesTotal * 2))
+  ) : void 0;
+  const summaryInputPathEvents = events.filter(
+    (event) => event.phase === "AUTO_COMPACT_SUMMARY_INPUT_PATH_APPLIED"
+  );
+  const structuredPrimaryPathEvents = summaryInputPathEvents.filter(
+    (event) => event.data?.mode === "structured_primary"
+  );
+  const structured_primary_path_rate = summaryInputPathEvents.length > 0 ? safeDivide(structuredPrimaryPathEvents.length, summaryInputPathEvents.length) : void 0;
+  const structured_semantic_coverage_rate = structured_primary_path_rate;
+  const qualityEvents = events.filter(
+    (event) => event.phase === "AUTO_COMPACT_SUMMARY_QUALITY"
+  );
+  const goalSamples = qualityEvents.filter(
+    (event) => typeof event.data?.taskGoalRetained === "boolean"
+  );
+  const resultSamples = qualityEvents.filter(
+    (event) => typeof event.data?.hasResultInput === "boolean"
+  );
+  const errorSamples = qualityEvents.filter(
+    (event) => typeof event.data?.hasErrorInput === "boolean"
+  );
+  const task_goal_retention_rate = goalSamples.length > 0 ? safeDivide(
+    goalSamples.filter((event) => event.data?.taskGoalRetained === true).length,
+    goalSamples.length
+  ) : void 0;
+  const result_fidelity_rate = resultSamples.length > 0 ? safeDivide(
+    resultSamples.filter((event) => {
+      if (event.data?.hasResultInput !== true) return true;
+      return event.data?.hasResultSummary === true;
+    }).length,
+    resultSamples.length
+  ) : void 0;
+  const error_fidelity_rate = errorSamples.length > 0 ? safeDivide(
+    errorSamples.filter((event) => {
+      if (event.data?.hasErrorInput !== true) return true;
+      return event.data?.hasErrorSummary === true;
+    }).length,
+    errorSamples.length
+  ) : void 0;
+  const first_turn_drift_rate = task_goal_retention_rate === void 0 ? void 0 : 1 - task_goal_retention_rate;
+  const restoreIntegrityEvents = events.filter(
+    (event) => event.phase === "TRACKER_RESTORE_INTEGRITY_CHECK"
+  );
+  const restoreIntegrityIssueCount = restoreIntegrityEvents.filter((event) => {
+    const isConsistent = event.data?.isConsistent;
+    if (typeof isConsistent === "boolean") return isConsistent === false;
+    return Number(event.data?.droppedCount ?? 0) > 0;
+  }).length;
+  const tracker_restore_integrity_issue_rate = restoreIntegrityEvents.length > 0 ? safeDivide(restoreIntegrityIssueCount, restoreIntegrityEvents.length) : void 0;
+  const userContentAdaptedEvents = events.filter(
+    (event) => event.phase === "MESSAGE_USER_CONTENT_ADAPTED"
+  );
+  const stringInputPathNumerator = userContentAdaptedEvents.reduce((sum, event) => {
+    const eventTotal = Number(event.data?.totalUserContentCount ?? 0);
+    const eventString = Number(event.data?.userStringContentCount ?? 0);
+    if (!Number.isFinite(eventTotal) || eventTotal <= 0) return sum;
+    if (!Number.isFinite(eventString) || eventString < 0) return sum;
+    return sum + Math.min(eventTotal, eventString);
+  }, 0);
+  const stringInputPathDenominator = userContentAdaptedEvents.reduce((sum, event) => {
+    const eventTotal = Number(event.data?.totalUserContentCount ?? 0);
+    if (!Number.isFinite(eventTotal) || eventTotal <= 0) return sum;
+    return sum + eventTotal;
+  }, 0);
+  const string_input_path_usage_rate = stringInputPathDenominator > 0 ? safeDivide(stringInputPathNumerator, stringInputPathDenominator) : void 0;
+  return {
+    compact_invalid_shape_rate,
+    compact_retry_success_rate,
+    thinking_first_ratio,
+    cross_model_replay_error_rate,
+    structured_primary_path_rate,
+    structured_semantic_coverage_rate,
+    typed_primary_path_rate,
+    typed_contract_fail_rate,
+    recoverable_failure_rate,
+    retry_exhausted_rate,
+    status_compensation_failure_rate,
+    compaction_boundary_hit_rate,
+    overflow_replay_success_rate,
+    compaction_reentry_success_rate,
+    noise_ratio_after_compaction,
+    task_goal_retention_rate,
+    result_fidelity_rate,
+    error_fidelity_rate,
+    first_turn_drift_rate,
+    tracker_restore_integrity_issue_rate,
+    string_input_path_usage_rate,
+    prune_marker_coverage_rate,
+    compacted_index_integrity_rate,
+    post_prune_noise_ratio,
+    tool_output_aging_hit_rate,
+    tool_output_placeholder_hit_rate,
+    tool_output_token_reduction_rate,
+    dangling_tool_closure_rate,
+    w11_sample_pass_rate,
+    w14_sample_pass_rate
+  };
+}
+
+// src/utils/session/autoCompactMetricsSink.ts
+function createAutoCompactMetricsSink() {
+  const events = [];
+  return {
+    push(event) {
+      events.push(event);
+    },
+    snapshot() {
+      return {
+        eventCount: events.length,
+        metrics: computeAutoCompactMetrics(events)
+      };
+    },
+    clear() {
+      events.length = 0;
+    }
+  };
+}
+
+// src/services/telemetry/autoCompactTelemetry.ts
+var AUTO_COMPACT_TELEMETRY_PHASES = /* @__PURE__ */ new Set([
+  "AUTO_COMPACT_FAILED",
+  "AUTO_COMPACT_RETRY",
+  "AUTO_COMPACT_FALLBACK",
+  "MESSAGE_TRANSFORM_APPLIED",
+  "AUTO_COMPACT_SUMMARY_INPUT_PATH_APPLIED",
+  "AUTO_COMPACT_SUMMARY_QUALITY",
+  "AUTO_COMPACT_BUDGET_APPLIED",
+  "AUTO_COMPACT_POST_PERSIST_CHECK",
+  "TRACKER_RESTORE_INTEGRITY_CHECK",
+  "COMPACTION_BOUNDARY_APPLIED",
+  "TOOL_OUTPUT_LIFECYCLE_APPLIED",
+  "SESSION_TYPED_PATH_APPLIED",
+  "SESSION_CANONICAL_FALLBACK_APPLIED",
+  "SESSION_TYPED_PATH_CONSISTENCY_FAILED",
+  "SESSION_TYPED_PATH_POLICY_APPLIED",
+  "SESSION_TYPED_PATH_AUTO_DEGRADED",
+  "MESSAGE_USER_CONTENT_ADAPTED",
+  "AUTO_COMPACT_TASK_NODE_CREATED",
+  "AUTO_COMPACT_TASK_NODE_TRANSITION",
+  "AUTO_COMPACT_TASK_NODE_FAILED",
+  "AUTO_COMPACT_OVERFLOW_JOINT_DECISION_DRAFT"
+]);
+var AUTO_COMPACT_SINK_LISTENER_ID = "auto-compact-metrics-sink";
+var autoCompactSink = createAutoCompactMetricsSink();
+var sinkRegistered = false;
+function ensureAutoCompactTelemetryRegistered() {
+  if (sinkRegistered) return;
+  registerTelemetryListener(AUTO_COMPACT_SINK_LISTENER_ID, (event) => {
+    if (!AUTO_COMPACT_TELEMETRY_PHASES.has(event.phase)) return;
+    autoCompactSink.push({
+      phase: event.phase,
+      data: event.data
+    });
+  });
+  sinkRegistered = true;
+}
+function emitAutoCompactTelemetryEvent(phase, data) {
+  ensureAutoCompactTelemetryRegistered();
+  emitTelemetryEvent({
+    channel: "auto_compact",
+    phase,
+    data,
+    timestamp: Date.now()
+  });
+}
+function getAutoCompactMetricsSnapshot() {
+  ensureAutoCompactTelemetryRegistered();
+  return autoCompactSink.snapshot();
+}
+function resetAutoCompactTelemetry() {
+  autoCompactSink.clear();
+}
+ensureAutoCompactTelemetryRegistered();
+
+// src/utils/messages/core.ts
+var INTERRUPT_MESSAGE = "[Request interrupted by user]";
+var INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool use]";
+var CANCEL_MESSAGE = "The user doesn't want to take this action right now. STOP what you are doing and wait for the user to tell you how to proceed.";
+var REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+var REJECT_MESSAGE_WITH_FEEDBACK_PREFIX = `The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). To tell you how to proceed, the user said:
+`;
+var REJECTED_PLAN_PREFIX = `The agent proposed a plan that was rejected by the user. The user chose to stay in plan mode rather than proceed with implementation.
+
+Rejected plan:
+`;
+var NO_RESPONSE_REQUESTED = "No response requested.";
+var SYNTHETIC_ASSISTANT_MESSAGES = /* @__PURE__ */ new Set([
+  INTERRUPT_MESSAGE,
+  INTERRUPT_MESSAGE_FOR_TOOL_USE,
+  CANCEL_MESSAGE,
+  REJECT_MESSAGE,
+  NO_RESPONSE_REQUESTED
+]);
+function stableUuidFromSeed(seed) {
+  const hex = createHash("sha256").update(seed).digest("hex").slice(0, 32);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function baseCreateAssistantMessage(content, extra) {
+  return {
+    type: "assistant",
+    costUSD: 0,
+    durationMs: 0,
+    uuid: randomUUID(),
+    message: {
+      id: randomUUID(),
+      model: "<synthetic>",
+      role: "assistant",
+      stop_reason: "stop_sequence",
+      stop_sequence: "",
+      type: "message",
+      usage: {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0
+      },
+      content
+    },
+    ...extra
+  };
+}
+function createAssistantMessage(content) {
+  return baseCreateAssistantMessage([
+    {
+      type: "text",
+      text: content === "" ? NO_CONTENT_MESSAGE : content,
+      citations: []
+    }
+  ]);
+}
+function createAssistantAPIErrorMessage(content) {
+  return baseCreateAssistantMessage(
+    [
+      {
+        type: "text",
+        text: content === "" ? NO_CONTENT_MESSAGE : content,
+        citations: []
+      }
+    ],
+    { isApiErrorMessage: true }
+  );
+}
+function createUserTextBlocks(content) {
+  return [{ type: "text", text: content }];
+}
+function createUserMessageFromBlocks(content, toolUseResult) {
+  const m = {
+    type: "user",
+    message: {
+      role: "user",
+      content
+    },
+    uuid: randomUUID(),
+    toolUseResult,
+    options: {
+      contentInputPath: "blocks"
+    }
+  };
+  return m;
+}
+function createUserMessageFromText(content, toolUseResult) {
+  const m = {
+    type: "user",
+    message: {
+      role: "user",
+      content: createUserTextBlocks(content)
+    },
+    uuid: randomUUID(),
+    toolUseResult,
+    options: {
+      contentInputPath: "blocks"
+    }
+  };
+  return m;
+}
+function generateQueryId() {
+  return randomUUID();
+}
+function createUserTurnMessageFromBlocks(content, toolUseResult) {
+  const m = createUserMessageFromBlocks(content, toolUseResult);
+  m.queryId = generateQueryId();
+  return m;
+}
+function createUserTurnMessageFromText(content, toolUseResult) {
+  const m = createUserMessageFromText(content, toolUseResult);
+  m.queryId = generateQueryId();
+  return m;
+}
+function createProgressMessage(toolUseID, siblingToolUseIDs, content, normalizedMessages, tools, meta) {
+  return {
+    type: "progress",
+    content,
+    normalizedMessages,
+    siblingToolUseIDs,
+    tools,
+    toolUseID,
+    progressState: meta?.progressState ?? "unknown",
+    uuid: randomUUID()
+  };
+}
+function filterProgressMessagesForTools(messages, toolNames) {
+  const toolUseIds = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.type !== "assistant") continue;
+    const block = message.message.content[0];
+    if (!isToolUseLikeBlockParam(block)) continue;
+    if (toolNames.has(block.name)) {
+      toolUseIds.add(block.id);
+    }
+  }
+  if (toolUseIds.size === 0) return messages;
+  return messages.filter(
+    (message) => message.type !== "progress" || !toolUseIds.has(message.toolUseID)
+  );
+}
+function createToolResultStopMessage(toolUseID) {
+  return {
+    type: "tool_result",
+    content: CANCEL_MESSAGE,
+    is_error: true,
+    tool_use_id: toolUseID
+  };
+}
+function extractTagFromMessage(message, tagName) {
+  if (message.type === "progress") {
+    return null;
+  }
+  if (typeof message.message.content !== "string") {
+    return null;
+  }
+  return extractTag(message.message.content, tagName);
+}
+function extractTag(html, tagName) {
+  if (!html.trim() || !tagName.trim()) {
+    return null;
+  }
+  const escapedTag = tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `<${escapedTag}(?:\\s+[^>]*)?>([\\s\\S]*?)<\\/${escapedTag}>`,
+    "gi"
+  );
+  let match;
+  let depth = 0;
+  let lastIndex = 0;
+  const openingTag = new RegExp(`<${escapedTag}(?:\\s+[^>]*?)?>`, "gi");
+  const closingTag = new RegExp(`<\\/${escapedTag}>`, "gi");
+  while ((match = pattern.exec(html)) !== null) {
+    const content = match[1];
+    const beforeMatch = html.slice(lastIndex, match.index);
+    depth = 0;
+    openingTag.lastIndex = 0;
+    while (openingTag.exec(beforeMatch) !== null) {
+      depth++;
+    }
+    closingTag.lastIndex = 0;
+    while (closingTag.exec(beforeMatch) !== null) {
+      depth--;
+    }
+    if (depth === 0 && content) {
+      return content;
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  return null;
+}
+function isNotEmptyMessage(message) {
+  if (message.type === "progress") {
+    return true;
+  }
+  if (typeof message.message.content === "string") {
+    return message.message.content.trim().length > 0;
+  }
+  if (message.message.content.length === 0) {
+    return false;
+  }
+  if (message.message.content.length > 1) {
+    return true;
+  }
+  if (message.message.content[0].type !== "text") {
+    return true;
+  }
+  return message.message.content[0].text.trim().length > 0 && message.message.content[0].text !== NO_CONTENT_MESSAGE && message.message.content[0].text !== INTERRUPT_MESSAGE_FOR_TOOL_USE;
+}
+function normalizeMessages(messages) {
+  return messages.flatMap((message) => {
+    if (message.type === "progress") {
+      return [message];
+    }
+    if (typeof message.message.content === "string") {
+      return [message];
+    }
+    const contentBlocks = message.message.content.filter(
+      (block) => !(block.type === "thinking" && (typeof block.thinking !== "string" || block.thinking.trim().length === 0))
+    );
+    return contentBlocks.map((block, blockIndex) => {
+      switch (message.type) {
+        case "assistant":
+          const baseSeed = String(
+            message.uuid ?? message.message?.id ?? randomUUID()
+          );
+          return {
+            type: "assistant",
+            uuid: stableUuidFromSeed(`${baseSeed}:${blockIndex}`),
+            message: {
+              ...message.message,
+              content: [block]
+            },
+            costUSD: message.costUSD / contentBlocks.length,
+            durationMs: message.durationMs
+          };
+        case "user":
+          return message;
+      }
+    });
+  });
+}
+function isToolUseLikeBlockParam(block) {
+  return block && typeof block === "object" && (block.type === "tool_use" || block.type === "server_tool_use" || block.type === "mcp_tool_use") && typeof block.id === "string";
+}
+function isToolUseRequestMessage(message) {
+  return message.type === "assistant" && "costUSD" in message && message.message.content.some(isToolUseLikeBlockParam);
+}
+function reorderMessages(messages) {
+  const ms = [];
+  const toolUseMessages = [];
+  for (const message of messages) {
+    if (isToolUseRequestMessage(message)) {
+      toolUseMessages.push(message);
+    }
+    if (message.type === "progress") {
+      const existingProgressMessage = ms.find(
+        (_) => _.type === "progress" && _.toolUseID === message.toolUseID
+      );
+      if (existingProgressMessage) {
+        ms[ms.indexOf(existingProgressMessage)] = message;
+        continue;
+      }
+      const toolUseMessage = toolUseMessages.find(
+        (_) => _.message.content[0]?.id === message.toolUseID
+      );
+      if (toolUseMessage) {
+        ms.splice(ms.indexOf(toolUseMessage) + 1, 0, message);
+        continue;
+      }
+    }
+    if (message.type === "user" && Array.isArray(message.message.content) && message.message.content[0]?.type === "tool_result") {
+      const toolUseID = message.message.content[0]?.tool_use_id;
+      const lastProgressMessage = ms.find(
+        (_) => _.type === "progress" && _.toolUseID === toolUseID
+      );
+      if (lastProgressMessage) {
+        ms.splice(ms.indexOf(lastProgressMessage) + 1, 0, message);
+        continue;
+      }
+      const toolUseMessage = toolUseMessages.find(
+        (_) => _.message.content[0]?.id === toolUseID
+      );
+      if (toolUseMessage) {
+        ms.splice(ms.indexOf(toolUseMessage) + 1, 0, message);
+        continue;
+      }
+    } else {
+      ms.push(message);
+    }
+  }
+  return ms;
+}
+var getToolResultIDs = memoize(
+  (normalizedMessages) => Object.fromEntries(
+    normalizedMessages.flatMap(
+      (_) => _.type === "user" && _.message.content[0]?.type === "tool_result" ? [
+        [
+          _.message.content[0].tool_use_id,
+          _.message.content[0].is_error ?? false
+        ]
+      ] : []
+    )
+  )
+);
+function getUnresolvedToolUseIDs(normalizedMessages) {
+  const toolResults = getToolResultIDs(normalizedMessages);
+  return new Set(
+    normalizedMessages.filter(
+      (_) => _.type === "assistant" && Array.isArray(_.message.content) && isToolUseLikeBlockParam(_.message.content[0]) && !(_.message.content[0].id in toolResults)
+    ).map((_) => _.message.content[0].id)
+  );
+}
+function getInProgressToolUseIDs(normalizedMessages) {
+  const unresolvedToolUseIDs = getUnresolvedToolUseIDs(normalizedMessages);
+  function isQueuedWaitingProgressMessage(message) {
+    if (message.type !== "progress") return false;
+    if (message.progressState === "queued_waiting") return true;
+    return false;
+  }
+  const toolUseIDsThatHaveProgressMessages = new Set(
+    normalizedMessages.filter(
+      (_) => _.type === "progress" && !isQueuedWaitingProgressMessage(_)
+    ).map((_) => _.toolUseID)
+  );
+  return new Set(
+    normalizedMessages.filter((_) => {
+      if (_.type !== "assistant") {
+        return false;
+      }
+      const firstBlock = _.message.content[0];
+      if (!isToolUseLikeBlockParam(firstBlock)) return false;
+      const toolUseID = firstBlock.id;
+      if (toolUseID === unresolvedToolUseIDs.values().next().value) {
+        return true;
+      }
+      if (toolUseIDsThatHaveProgressMessages.has(toolUseID) && unresolvedToolUseIDs.has(toolUseID)) {
+        return true;
+      }
+      return false;
+    }).map((_) => _.message.content[0].id)
+  );
+}
+function getErroredToolUseMessages(normalizedMessages) {
+  const toolResults = getToolResultIDs(normalizedMessages);
+  return normalizedMessages.filter(
+    (_) => _.type === "assistant" && Array.isArray(_.message.content) && isToolUseLikeBlockParam(_.message.content[0]) && _.message.content[0].id in toolResults && toolResults[_.message.content[0].id]
+  );
+}
+function normalizeMessagesForAPI(messages) {
+  function isSyntheticApiErrorMessage(message) {
+    return message.type === "assistant" && message.isApiErrorMessage === true && message.message.model === "<synthetic>";
+  }
+  function normalizeUserContent(content) {
+    if (typeof content === "string") {
+      return [{ type: "text", text: content }];
+    }
+    return content;
+  }
+  function toolResultsFirst(content) {
+    const toolResults = [];
+    const rest = [];
+    for (const block of content) {
+      if (block.type === "tool_result") {
+        toolResults.push(block);
+      } else {
+        rest.push(block);
+      }
+    }
+    return [...toolResults, ...rest];
+  }
+  function mergeUserMessages(base, next) {
+    const baseBlocks = normalizeUserContent(base.message.content);
+    const nextBlocks = normalizeUserContent(next.message.content);
+    return {
+      ...base,
+      message: {
+        ...base.message,
+        content: toolResultsFirst([...baseBlocks, ...nextBlocks])
+      }
+    };
+  }
+  function isUserToolResultMessage(message) {
+    if (message.type !== "user") return false;
+    if (!Array.isArray(message.message.content)) return false;
+    return message.message.content.some((block) => block.type === "tool_result");
+  }
+  const result = [];
+  let userStringContentCount = 0;
+  let totalUserContentCount = 0;
+  for (const message of messages) {
+    if (message.type === "progress") continue;
+    if (isSyntheticApiErrorMessage(message)) continue;
+    switch (message.type) {
+      case "user": {
+        totalUserContentCount += 1;
+        if (typeof message.message.content === "string") {
+          userStringContentCount += 1;
+        }
+        const prev = last(result);
+        if (prev?.type === "user") {
+          result[result.indexOf(prev)] = mergeUserMessages(prev, message);
+        } else {
+          result.push(message);
+        }
+        break;
+      }
+      case "assistant": {
+        let merged = false;
+        for (let i = result.length - 1; i >= 0; i--) {
+          const prev = result[i];
+          if (prev.type !== "assistant" && !isUserToolResultMessage(prev)) {
+            break;
+          }
+          if (prev.type === "assistant") {
+            if (prev.message.id === message.message.id) {
+              result[i] = {
+                ...prev,
+                message: {
+                  ...prev.message,
+                  content: [
+                    ...Array.isArray(prev.message.content) ? prev.message.content : [],
+                    ...Array.isArray(message.message.content) ? message.message.content : []
+                  ]
+                }
+              };
+              merged = true;
+            }
+            break;
+          }
+        }
+        if (!merged) {
+          result.push(message);
+        }
+        break;
+      }
+    }
+  }
+  emitAutoCompactTelemetryEvent("MESSAGE_USER_CONTENT_ADAPTED", {
+    totalUserContentCount,
+    userStringContentCount,
+    string_input_path_usage_rate: totalUserContentCount > 0 ? userStringContentCount / totalUserContentCount : 0
+  });
+  return result;
+}
+function normalizeContentFromAPI(content) {
+  const filteredContent = content.filter(
+    (_) => _.type !== "text" || _.text.trim().length > 0
+  );
+  if (filteredContent.length === 0) {
+    return [{ type: "text", text: NO_CONTENT_MESSAGE, citations: [] }];
+  }
+  return filteredContent;
+}
+function isEmptyMessageText(text) {
+  return stripSystemMessages(text).trim() === "" || text.trim() === NO_CONTENT_MESSAGE;
+}
+var STRIPPED_TAGS = [
+  "commit_analysis",
+  "context",
+  "function_analysis",
+  "pr_analysis"
+];
+function stripSystemMessages(content) {
+  const regex = new RegExp(`<(${STRIPPED_TAGS.join("|")})>.*?</\\1>
+?`, "gs");
+  return content.replace(regex, "").trim();
+}
+function getToolUseID(message) {
+  switch (message.type) {
+    case "assistant":
+      return isToolUseLikeBlockParam(message.message.content[0]) ? message.message.content[0].id : null;
+    case "user":
+      if (message.message.content[0]?.type !== "tool_result") {
+        return null;
+      }
+      return message.message.content[0].tool_use_id;
+    case "progress":
+      return message.toolUseID;
+  }
+}
+function getLastAssistantMessageId(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message && message.type === "assistant") {
+      return message.message.id;
+    }
+  }
+  return void 0;
+}
+
+// src/utils/messages/index.ts
+async function processUserInput(input, mode, setToolJSX, context, pastedImages) {
+  const impl = await import("./userInput-75VCTJDE.js");
+  return impl.processUserInput(input, mode, setToolJSX, context, pastedImages);
+}
+
+export {
+  API_ERROR_MESSAGE_PREFIX,
+  PROMPT_TOO_LONG_ERROR_MESSAGE,
+  CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE,
+  INVALID_API_KEY_ERROR_MESSAGE,
+  NO_CONTENT_MESSAGE,
+  MAIN_QUERY_TEMPERATURE,
+  registerTelemetryListener,
+  emitTelemetryEvent,
+  emitAutoCompactTelemetryEvent,
+  getAutoCompactMetricsSnapshot,
+  resetAutoCompactTelemetry,
+  INTERRUPT_MESSAGE,
+  INTERRUPT_MESSAGE_FOR_TOOL_USE,
+  CANCEL_MESSAGE,
+  REJECT_MESSAGE,
+  REJECT_MESSAGE_WITH_FEEDBACK_PREFIX,
+  REJECTED_PLAN_PREFIX,
+  NO_RESPONSE_REQUESTED,
+  SYNTHETIC_ASSISTANT_MESSAGES,
+  createAssistantMessage,
+  createAssistantAPIErrorMessage,
+  createUserMessageFromBlocks,
+  createUserMessageFromText,
+  generateQueryId,
+  createUserTurnMessageFromBlocks,
+  createUserTurnMessageFromText,
+  createProgressMessage,
+  filterProgressMessagesForTools,
+  createToolResultStopMessage,
+  extractTagFromMessage,
+  extractTag,
+  isNotEmptyMessage,
+  normalizeMessages,
+  reorderMessages,
+  getUnresolvedToolUseIDs,
+  getInProgressToolUseIDs,
+  getErroredToolUseMessages,
+  normalizeMessagesForAPI,
+  normalizeContentFromAPI,
+  isEmptyMessageText,
+  stripSystemMessages,
+  getToolUseID,
+  getLastAssistantMessageId,
+  processUserInput
+};