nolo-cli 0.54.0 → 0.61.0-alpha.2

package/handleSendMessageAction-DF2OABGW.js

@@ -0,0 +1,675 @@
+import {
+  waitForAbortableDelay
+} from "./chunk-N4G4PKQ6.js";
+import {
+  messageStreamEnd,
+  prepareAndPersistUserMessage,
+  resolveHandleSendMessageContext,
+  selectAllMsgs
+} from "./chunk-D5XKNNUV.js";
+import "./chunk-EVBFYPDC.js";
+import "./chunk-HQUORJTM.js";
+import "./chunk-YYLHWIW6.js";
+import "./chunk-AGGIDPCZ.js";
+import {
+  streamAgentChatTurn
+} from "./chunk-HQP7HJDL.js";
+import "./chunk-4NJEIGBQ.js";
+import "./chunk-5RGU3J7P.js";
+import {
+  addActiveController,
+  getActiveDialogKey,
+  removeActiveController
+} from "./chunk-6YTOJY35.js";
+import "./chunk-M76ECQRD.js";
+import "./chunk-YDH3FDFQ.js";
+import "./chunk-5ZYA4JJ3.js";
+import "./chunk-Z4QSJILV.js";
+import "./chunk-LJKICKVC.js";
+import "./chunk-PSCNXBYA.js";
+import "./chunk-BYXBJQAS.js";
+import "./chunk-MMZ6ZTVO.js";
+import "./chunk-DWLEOOGR.js";
+import "./chunk-3JQ2NRYU.js";
+import "./chunk-ONXOABJR.js";
+import "./chunk-W7XHHYWM.js";
+import "./chunk-HNMXYYJR.js";
+import "./chunk-BYEJ7K2Z.js";
+import "./chunk-FKFMIBTT.js";
+import "./chunk-22BTGNSP.js";
+import "./chunk-VMWYBIXG.js";
+import "./chunk-Y5GCAMGP.js";
+import "./chunk-UZ6XXCVR.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-RVWRKFUB.js";
+import "./chunk-UAD2WT54.js";
+import {
+  readAndWait,
+  selectById
+} from "./chunk-DNNSCSA2.js";
+import {
+  createDialogMessageKeyAndId
+} from "./chunk-NHRQCXIQ.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-I42VC5KR.js";
+import "./chunk-SOJM57FX.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-L7B47JXR.js";
+import {
+  extractCustomId
+} from "./chunk-BJIRLHJR.js";
+import "./chunk-KWSQR2KK.js";
+import "./chunk-QOKAKDPE.js";
+import "./chunk-OW765XBU.js";
+import "./chunk-SEJ5OS6F.js";
+import "./chunk-GBRG75BQ.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/chat/dialog/actions/parseOAuthError.ts
+var PROVIDER_NAMES = {
+  antigravity: "Antigravity (Google)",
+  claude: "Claude",
+  chatgpt: "ChatGPT",
+  xai: "xAI Grok",
+  cursor: "Cursor",
+  cloudflare: "Cloudflare"
+};
+function asRecord(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return null;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function sanitizeSafeUrl(rawUrl) {
+  if (typeof rawUrl !== "string") return void 0;
+  const trimmed = rawUrl.trim();
+  if (/^https?:\/\//i.test(trimmed)) {
+    try {
+      const parsed = new URL(trimmed);
+      if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+        return trimmed;
+      }
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function extractFullErrorText(error) {
+  if (!error) return "Unknown error";
+  if (typeof error === "string") return error;
+  if (error instanceof Error) {
+    let msg = error.message || error.name || String(error);
+    const seen = /* @__PURE__ */ new Set([error]);
+    let current = error.cause;
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      const causeMsg = current instanceof Error ? current.message || String(current) : typeof current === "string" ? current : JSON.stringify(current);
+      if (causeMsg && !msg.includes(causeMsg)) {
+        msg = `${msg}
+[cause]: ${causeMsg}`;
+      }
+      current = current?.cause;
+    }
+    return msg;
+  }
+  return error?.message || error?.error || String(error);
+}
+function collectValidationFromDetails(details) {
+  if (!Array.isArray(details)) return {};
+  let url;
+  let text;
+  let learnMoreUrl;
+  for (const detail of details) {
+    const rec = asRecord(detail);
+    if (!rec) continue;
+    const metadata = asRecord(rec.metadata);
+    if (metadata) {
+      url = url ?? sanitizeSafeUrl(metadata.validation_url);
+      text = text ?? asString(metadata.validation_url_link_text);
+      learnMoreUrl = learnMoreUrl ?? sanitizeSafeUrl(metadata.validation_learn_more_url);
+    }
+    const help = asRecord(rec);
+    if (Array.isArray(help.links)) {
+      for (const link of help.links) {
+        const linkRec = asRecord(link);
+        if (!linkRec) continue;
+        const linkUrl = sanitizeSafeUrl(linkRec.url);
+        if (!linkUrl) continue;
+        const desc = asString(linkRec.description);
+        if (!url && desc && /verify|continue/i.test(desc)) {
+          url = linkUrl;
+          text = desc;
+        } else if (!learnMoreUrl && /learn more/i.test(desc ?? "")) {
+          learnMoreUrl = linkUrl;
+        }
+      }
+    }
+  }
+  return { url, text, learnMoreUrl };
+}
+function resolveErrorStage(errorText) {
+  if (/127\.0\.0\.1:3233|localhost:3233|desktop daemon|desktop agent runtime|runDesktopAgentRuntime|Local turn stream/i.test(
+    errorText
+  )) {
+    return "desktop_local_runtime";
+  }
+  if (/\/api\/ai\/chat\/proxy|server proxy|core_draining|fetchWithServerProxy/i.test(
+    errorText
+  )) {
+    return "server_proxy";
+  }
+  if (/OAuth provider failed|provider failed|antigravity|claude|chatgpt|openai|gemini|deepseek/i.test(
+    errorText
+  )) {
+    return "provider";
+  }
+  return void 0;
+}
+function parseSendError(errorInput) {
+  const fullErrorText = extractFullErrorText(errorInput).trim();
+  const firstLine = fullErrorText.replace(/^local\s+/, "").split("\n")[0].trim();
+  const providerMatch = fullErrorText.match(/local\s+(\w+)\s+OAuth provider failed/i);
+  const providerName = providerMatch ? PROVIDER_NAMES[providerMatch[1].toLowerCase()] ?? providerMatch[1] : void 0;
+  const statusMatch = fullErrorText.match(/HTTP\s+(\d{3})/i) || fullErrorText.match(/\bstatus(?:\s+code)?[:=]?\s*(\d{3})\b/i) || fullErrorText.match(/^(?:HTTP\/[\d.]+\s+)?([45]\d{2})\b/i);
+  const status = statusMatch?.[1];
+  const statusCode = status ? parseInt(status, 10) : void 0;
+  const jsonStart = fullErrorText.indexOf("{");
+  let payload = null;
+  if (jsonStart >= 0) {
+    let candidate = fullErrorText.slice(jsonStart);
+    for (let depth = 0; depth < 3; depth += 1) {
+      try {
+        const parsed = JSON.parse(candidate);
+        payload = parsed;
+        const message = asString(
+          parsed?.error?.message ?? parsed?.message
+        );
+        if (message && message.trim().startsWith("{")) {
+          candidate = message;
+          continue;
+        }
+        break;
+      } catch {
+        break;
+      }
+    }
+  }
+  const errorRec = payload ? asRecord(payload.error) : null;
+  const innerMessage = errorRec ? asString(errorRec.message) : void 0;
+  const statusFromBody = errorRec ? asString(errorRec.status) : void 0;
+  const details = errorRec?.details;
+  const { url, text, learnMoreUrl } = collectValidationFromDetails(details);
+  let reason = errorRec ? asString(errorRec.reason) : void 0;
+  let domain = errorRec ? asString(errorRec.domain) : void 0;
+  if (!reason && Array.isArray(details)) {
+    const first = asRecord(details[0]);
+    reason = first ? asString(first.reason) : void 0;
+    domain = first ? asString(first.domain) : void 0;
+  }
+  const stage = resolveErrorStage(fullErrorText);
+  let kind = "unknown";
+  let retryable = true;
+  const isLocalConnRefused = /ECONNREFUSED/i.test(fullErrorText) && (/127\.0\.0\.1/i.test(fullErrorText) || /localhost/i.test(fullErrorText));
+  const hasExplicitAuthKeywords = /unauthorized|unauthenticated|permission_denied|validation_required|invalid_api_key|api key not found|authentication error|forbidden/i.test(
+    fullErrorText
+  );
+  if (statusCode === 429) {
+    kind = "rate_limit";
+    retryable = true;
+  } else if (statusCode === 401 || statusCode === 403 || hasExplicitAuthKeywords) {
+    kind = "auth";
+    retryable = false;
+  } else if (statusCode && statusCode >= 500 && statusCode < 600) {
+    kind = "server";
+    retryable = true;
+  } else if (/timed out|timeout|ETIMEDOUT|deadline exceeded|upstream request timeout/i.test(
+    fullErrorText
+  ) || /aborted due to timeout/i.test(fullErrorText)) {
+    kind = "timeout";
+    retryable = true;
+  } else if (/failed to fetch|network error|fetch failed|load failed|network request failed|networkerror|ECONNREFUSED|ENOTFOUND|ECONNRESET|EHOSTUNREACH|ENETUNREACH|EAI_AGAIN|UND_ERR_CONNECT_TIMEOUT|UND_ERR_SOCKET|socket hang up|socket closed|connection closed|certificate|handshake/i.test(
+    fullErrorText
+  )) {
+    kind = "network";
+    retryable = true;
+  } else if (/rate limit|too many requests|quota exceeded|resource exhausted|insufficient_quota/i.test(
+    fullErrorText
+  )) {
+    kind = "rate_limit";
+    retryable = true;
+  } else if (/internal server error|bad gateway|service unavailable|gateway timeout|core_draining/i.test(
+    fullErrorText
+  )) {
+    kind = "server";
+    retryable = true;
+  } else {
+    kind = "unknown";
+    retryable = true;
+  }
+  const parts = [];
+  if (providerName) {
+    const head = `${providerName} \u8FDE\u63A5\u5931\u8D25`;
+    parts.push(
+      `${head}${status ? ` (HTTP ${status})` : ""}${statusFromBody ? ` ${statusFromBody}` : ""}`
+    );
+  } else {
+    switch (kind) {
+      case "network":
+        if (isLocalConnRefused) {
+          parts.push("\u672C\u5730\u670D\u52A1\u8FDE\u63A5\u5931\u8D25");
+        } else if (/ENOTFOUND/i.test(fullErrorText)) {
+          parts.push("\u57DF\u540D\u89E3\u6790\u5931\u8D25");
+        } else {
+          parts.push("\u8FDE\u63A5\u4E2D\u65AD");
+        }
+        break;
+      case "timeout":
+        parts.push("\u8BF7\u6C42\u8D85\u65F6");
+        break;
+      case "rate_limit":
+        parts.push(`\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41${status ? ` (HTTP ${status})` : ""}`);
+        break;
+      case "auth":
+        parts.push(`\u8BA4\u8BC1\u6216\u6743\u9650\u6821\u9A8C\u5931\u8D25${status ? ` (HTTP ${status})` : ""}`);
+        break;
+      case "server":
+        parts.push(`\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528${status ? ` (HTTP ${status})` : ""}`);
+        break;
+      default:
+        parts.push(firstLine.length > 0 ? firstLine : "\u53D1\u9001\u9047\u5230\u5F02\u5E38");
+        break;
+    }
+  }
+  if (reason) {
+    parts.push(`\u539F\u56E0\uFF1A${reason}`);
+  }
+  if (domain) {
+    parts.push(`\u670D\u52A1\uFF1A${domain}`);
+  }
+  const humanMessage = innerMessage && innerMessage.trim() !== "Verify your account to continue." ? innerMessage : void 0;
+  if (humanMessage) {
+    parts.push(`\u63D0\u793A\uFF1A${humanMessage}`);
+  }
+  let actionHint;
+  if (url) {
+    actionHint = "\u8BF7\u70B9\u51FB\u94FE\u63A5\u5B8C\u6210\u9A8C\u8BC1";
+  } else {
+    switch (kind) {
+      case "network":
+        if (isLocalConnRefused) {
+          actionHint = "\u65E0\u6CD5\u8FDE\u63A5\u5230\u672C\u5730\u670D\u52A1\uFF0C\u8BF7\u786E\u8BA4\u684C\u9762\u7AEF\u540E\u53F0\u670D\u52A1\u6B63\u5728\u8FD0\u884C\u540E\u91CD\u8BD5";
+        } else if (/ENOTFOUND/i.test(fullErrorText)) {
+          actionHint = "\u65E0\u6CD5\u89E3\u6790\u670D\u52A1\u5730\u5740\uFF0C\u53EF\u80FD\u662F DNS \u6216\u7F51\u7EDC\u73AF\u5883\u6CE2\u52A8\uFF0C\u70B9\u51FB\u91CD\u8BD5\u901A\u5E38\u53EF\u6062\u590D";
+        } else {
+          actionHint = "\u53EF\u80FD\u662F\u7F51\u7EDC\u6CE2\u52A8\u6216\u670D\u52A1\u7AEF\u77AC\u65F6\u95EE\u9898\uFF0C\u70B9\u51FB\u91CD\u8BD5\u901A\u5E38\u53EF\u6062\u590D";
+        }
+        break;
+      case "timeout":
+        actionHint = "\u670D\u52A1\u54CD\u5E94\u8D85\u65F6\uFF0C\u53EF\u80FD\u662F\u7F51\u7EDC\u6CE2\u52A8\u6216\u670D\u52A1\u8D1F\u8F7D\u8F83\u9AD8\uFF0C\u70B9\u51FB\u91CD\u8BD5\u901A\u5E38\u53EF\u6062\u590D";
+        break;
+      case "rate_limit":
+        actionHint = "\u5DF2\u8FBE\u5230\u8C03\u7528\u9891\u7387\u6216\u914D\u989D\u9650\u5236\uFF0C\u8BF7\u7A0D\u5019\u7247\u523B\u540E\u91CD\u8BD5";
+        break;
+      case "auth":
+        actionHint = "\u8BF7\u68C0\u67E5\u8D26\u53F7\u767B\u5F55\u72B6\u6001\u6216 API \u5BC6\u94A5\u914D\u7F6E";
+        break;
+      case "server":
+        actionHint = "\u670D\u52A1\u7AEF\u53D1\u751F\u77AC\u65F6\u5F02\u5E38\uFF0C\u70B9\u51FB\u91CD\u8BD5\u901A\u5E38\u53EF\u6062\u590D";
+        break;
+      case "unknown":
+      default:
+        actionHint = "\u9047\u5230\u5F02\u5E38\uFF0C\u70B9\u51FB\u91CD\u8BD5\u901A\u5E38\u53EF\u6062\u590D";
+        break;
+    }
+  }
+  const extraLinks = [];
+  if (learnMoreUrl) {
+    extraLinks.push({ text: "\u4E86\u89E3\u66F4\u591A", url: learnMoreUrl });
+  }
+  const summary = parts.join("\n");
+  if (url) {
+    return {
+      kind,
+      retryable,
+      stage,
+      actionHint,
+      summary,
+      validationUrl: url,
+      validationLinkText: text ?? "\u9A8C\u8BC1\u6211\u7684\u8D26\u53F7",
+      extraLinks
+    };
+  }
+  const MAX_FALLBACK = 800;
+  const fallbackText = fullErrorText.length > MAX_FALLBACK ? `${fullErrorText.slice(0, MAX_FALLBACK)}\u2026` : fullErrorText;
+  return {
+    kind,
+    retryable,
+    stage,
+    actionHint,
+    summary,
+    extraLinks,
+    fallbackText
+  };
+}
+function buildSendErrorMessageMarkdown(parsed) {
+  const lines = ["[\u53D1\u9001\u5931\u8D25]", "", parsed.summary];
+  if (parsed.actionHint && !parsed.validationUrl) {
+    lines.push("", `\u5EFA\u8BAE\uFF1A${parsed.actionHint}`);
+  }
+  if (parsed.validationUrl) {
+    lines.push(
+      "",
+      `\u8BF7\u70B9\u51FB\u94FE\u63A5\u5B8C\u6210\u9A8C\u8BC1\uFF1A`,
+      `- [${parsed.validationLinkText ?? "\u9A8C\u8BC1\u6211\u7684\u8D26\u53F7"}](${parsed.validationUrl})`
+    );
+  }
+  for (const link of parsed.extraLinks) {
+    lines.push(`- [${link.text}](${link.url})`);
+  }
+  if (parsed.fallbackText && !parsed.validationUrl) {
+    lines.push("", "```", parsed.fallbackText, "```");
+  }
+  return lines.join("\n");
+}
+
+// packages/chat/dialog/actions/handleSendMessageAction.ts
+var getDialogConfig = (state, dialogKey) => {
+  const resolvedDialogKey = dialogKey ?? getActiveDialogKey();
+  if (!resolvedDialogKey) return null;
+  const dialog = selectById(state, resolvedDialogKey);
+  return dialog ?? null;
+};
+var ensureDialogConfig = async (dispatch, getState, dialogKey) => {
+  const state = getState();
+  const resolvedDialogKey = dialogKey ?? getActiveDialogKey();
+  if (!resolvedDialogKey) return null;
+  try {
+    const existingDialog = getDialogConfig(state, resolvedDialogKey);
+    if (existingDialog && Array.isArray(existingDialog.cybots) && existingDialog.cybots.length > 0) {
+      return existingDialog;
+    }
+    const persistedDialog = await dispatch(readAndWait(resolvedDialogKey)).unwrap();
+    if (persistedDialog) return persistedDialog;
+    return existingDialog;
+  } catch {
+    return getDialogConfig(getState(), resolvedDialogKey);
+  }
+};
+var logQuickChatPerfStage = (startedAt, stage, details = {}) => {
+  if (!startedAt) return;
+  const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+  console.info("[QuickChatPerf]", {
+    stage,
+    elapsedMs: now - startedAt,
+    ...typeof performance !== "undefined" ? { atMs: now } : {},
+    ...details
+  });
+};
+var resolveBrowseContextPrefix = async (message) => {
+  try {
+    if (typeof window === "undefined" || typeof location === "undefined") return "";
+    if (typeof process !== "undefined" && (process.env?.NODE_ENV === "test" || process.env?.BUN_TEST)) return "";
+    const host = location.hostname;
+    if (host !== "127.0.0.1" && host !== "localhost") return "";
+    if (typeof fetch !== "function" || typeof AbortSignal?.timeout !== "function") return "";
+    const response = await fetch("/api/desktop/browse-context", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ message }),
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!response.ok) return "";
+    const payload = await response.json();
+    if (!payload.context || !payload.context.url) return "";
+    const ctx = payload.context;
+    const parts = [`[\u5F53\u524D\u6D4F\u89C8\u4E0A\u4E0B\u6587]`, `URL: ${ctx.url}`, `\u6807\u9898: ${ctx.title}`];
+    if (ctx.textSnippet) parts.push(`\u6458\u8981: ${ctx.textSnippet.slice(0, 2e3)}`);
+    return parts.join("\n");
+  } catch {
+    return "";
+  }
+};
+var finalizeQuickChatStreamStartupFailure = async (dispatch, dialogConfig, agentKey) => {
+  const dialogKey = dialogConfig.dbKey;
+  const dialogId = dialogConfig.id ?? (dialogKey ? extractCustomId(dialogKey) : "");
+  const { key: msgKey, messageId } = createDialogMessageKeyAndId(dialogId);
+  await dispatch(
+    messageStreamEnd({
+      finalContentBuffer: [
+        {
+          type: "text",
+          text: "[\u9519\u8BEF: \u672A\u80FD\u542F\u52A8\u6A21\u578B\u56DE\u590D\uFF0C\u8BF7\u91CD\u8BD5\u3002]"
+        }
+      ],
+      totalUsage: null,
+      msgKey,
+      agentConfig: {
+        dbKey: agentKey
+      },
+      dialogId,
+      dialogKey: dialogKey ?? "",
+      messageId,
+      reasoningBuffer: ""
+    })
+  ).unwrap?.();
+};
+var finalizeSendFailureInDialog = async (dispatch, dialogConfig, agentKey, errorInput) => {
+  const dialogKey = dialogConfig.dbKey;
+  const dialogId = dialogConfig.id ?? (dialogKey ? extractCustomId(dialogKey) : "");
+  const { key: msgKey, messageId } = createDialogMessageKeyAndId(dialogId);
+  const parsed = parseSendError(errorInput);
+  const errorMeta = {
+    kind: parsed.kind,
+    retryable: parsed.retryable,
+    stage: parsed.stage,
+    summary: parsed.summary,
+    actionHint: parsed.actionHint,
+    validationUrl: parsed.validationUrl,
+    validationLinkText: parsed.validationLinkText,
+    extraLinks: parsed.extraLinks,
+    fallbackText: parsed.fallbackText,
+    rawError: parsed.fallbackText
+  };
+  await dispatch(
+    messageStreamEnd({
+      finalContentBuffer: [
+        {
+          type: "text",
+          text: buildSendErrorMessageMarkdown(parsed)
+        }
+      ],
+      totalUsage: null,
+      msgKey,
+      agentConfig: {
+        dbKey: agentKey
+      },
+      dialogId,
+      dialogKey: dialogKey ?? "",
+      messageId,
+      reasoningBuffer: "",
+      messageMetadata: {
+        errorMeta
+      }
+    })
+  ).unwrap?.();
+};
+var handleSendMessageAction = async (args, { dispatch, getState, rejectWithValue }) => {
+  let dialogConfig = null;
+  let agentKeyToUse;
+  try {
+    logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-entered", {
+      dialogKey: args.dialogKey ?? null
+    });
+    dialogConfig = await ensureDialogConfig(dispatch, getState, args.dialogKey);
+    if (!dialogConfig) {
+      throw new Error(
+        "handleSendMessage: Dialog configuration is missing."
+      );
+    }
+    logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-dialog-ready", {
+      dialogKey: dialogConfig.dbKey,
+      cybotCount: dialogConfig.cybots?.length ?? 0
+    });
+    let effectiveRawUserInput = args.userInput;
+    if (args.isRetry) {
+      if (!effectiveRawUserInput) {
+        const dialogId = dialogConfig.id ?? (dialogConfig.dbKey ? extractCustomId(dialogConfig.dbKey) : "");
+        const state = getState();
+        try {
+          const messages = selectAllMsgs(state, dialogId);
+          if (Array.isArray(messages) && messages.length > 0) {
+            let targetIndex = messages.length - 1;
+            if (args.retryMessageId) {
+              const foundIdx = messages.findIndex((m) => m?.id === args.retryMessageId);
+              if (foundIdx >= 0) {
+                targetIndex = foundIdx;
+              }
+            }
+            for (let i = targetIndex; i >= 0; i--) {
+              const m = messages[i];
+              if (m?.role === "user" && m.content) {
+                effectiveRawUserInput = m.content;
+                break;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      if (!effectiveRawUserInput || typeof effectiveRawUserInput === "string" && !effectiveRawUserInput.trim() || Array.isArray(effectiveRawUserInput) && effectiveRawUserInput.length === 0) {
+        console.warn("[handleSendMessage] isRetry: No preceding user message found to retry.");
+        return rejectWithValue("\u672A\u627E\u5230\u53EF\u91CD\u8BD5\u7684\u7528\u6237\u8F93\u5165");
+      }
+    } else {
+      await dispatch(
+        prepareAndPersistUserMessage({
+          userInput: args.userInput ?? "",
+          dialogConfig
+        })
+      ).unwrap();
+      logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-user-persisted", {
+        dialogKey: dialogConfig.dbKey
+      });
+    }
+    const resolvedContext = resolveHandleSendMessageContext({
+      dialogConfig,
+      targetAgentKey: args.targetAgentKey,
+      runtimeOptions: args.runtimeOptions
+    });
+    agentKeyToUse = resolvedContext.agentKeyToUse;
+    const agentConfigToUse = resolvedContext.agentConfigToUse;
+    const effectiveRuntimeOptions = resolvedContext.effectiveRuntimeOptions;
+    if (!agentKeyToUse) {
+      return;
+    }
+    const userInputText = typeof effectiveRawUserInput === "string" ? effectiveRawUserInput : "";
+    const isDesktopContext = typeof window !== "undefined" && typeof location !== "undefined" && (location.hostname === "127.0.0.1" || location.hostname === "localhost");
+    const browseContextPrefix = isDesktopContext ? await resolveBrowseContextPrefix(userInputText) : "";
+    const effectiveUserInput = browseContextPrefix ? `${browseContextPrefix}
+
+${userInputText}` : effectiveRawUserInput ?? "";
+    let streamResult;
+    const maxStartupAttempts = 2;
+    for (let attempt = 1; attempt <= maxStartupAttempts; attempt++) {
+      try {
+        streamResult = await dispatch(
+          streamAgentChatTurn({
+            agentKey: agentKeyToUse,
+            ...agentConfigToUse ? { agentConfig: agentConfigToUse } : {},
+            userInput: effectiveUserInput,
+            dialogKey: dialogConfig.dbKey,
+            parentMessageId: void 0,
+            runtimeOptions: effectiveRuntimeOptions,
+            quickChatPerfStartedAt: args.quickChatPerfStartedAt
+          })
+        ).unwrap();
+        if (streamResult && typeof streamResult === "object" && streamResult.aborted) {
+          return;
+        }
+        break;
+      } catch (turnErr) {
+        const parsed = parseSendError(turnErr);
+        if (attempt < maxStartupAttempts && (parsed.kind === "network" || parsed.kind === "timeout")) {
+          const delayMs = attempt * 800;
+          const retryAbortController = new AbortController();
+          const retryKey = `retry:${dialogConfig.dbKey ?? "global"}`;
+          try {
+            dispatch(
+              addActiveController({
+                messageId: retryKey,
+                controller: retryAbortController,
+                dialogKey: dialogConfig.dbKey
+              })
+            );
+            await waitForAbortableDelay(delayMs, retryAbortController.signal);
+          } catch {
+          } finally {
+            dispatch(
+              removeActiveController({
+                messageId: retryKey,
+                dialogKey: dialogConfig.dbKey
+              })
+            );
+          }
+          if (retryAbortController.signal.aborted) {
+            console.info("[handleSendMessage] Auto-retry cancelled by user stop during backoff window.");
+            return;
+          }
+          continue;
+        }
+        throw turnErr;
+      }
+    }
+    if (args.quickChatPerfStartedAt && streamResult === void 0) {
+      logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-stream-empty", {
+        dialogKey: dialogConfig.dbKey,
+        agentKey: agentKeyToUse
+      });
+      await finalizeQuickChatStreamStartupFailure(
+        dispatch,
+        dialogConfig,
+        agentKeyToUse
+      );
+      return;
+    }
+    logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-stream-finished", {
+      dialogKey: dialogConfig.dbKey,
+      agentKey: agentKeyToUse
+    });
+    return;
+  } catch (error) {
+    console.error("handleSendMessage failed:", error);
+    const errorMessage = error instanceof Error ? error.message : typeof error === "string" ? error : error?.message || error?.error || String(error);
+    try {
+      if (dialogConfig && agentKeyToUse) {
+        await finalizeSendFailureInDialog(
+          dispatch,
+          dialogConfig,
+          agentKeyToUse,
+          error
+        );
+        return rejectWithValue({
+          __errorInDialog: true,
+          message: errorMessage
+        });
+      }
+    } catch (writeError) {
+      console.error("handleSendMessage: failed to write error into dialog:", writeError);
+    }
+    return rejectWithValue(errorMessage);
+  }
+};
+export {
+  handleSendMessageAction
+};