nolo-cli 0.108.0-alpha.1 → 0.108.0

package/handleSendMessageAction-TYDPIC6O.js

@@ -0,0 +1,1849 @@
+import {
+  scanValidationDetails
+} from "./chunk-BMQ2MJUK.js";
+import {
+  buildForegroundTurnAdmissionFetchInit,
+  consumeAgentRunStream,
+  mergeAgentToolsWithRuntime,
+  projectDesktopToolUiContent,
+  resolveTurnToolContext
+} from "./chunk-7YVPCIEN.js";
+import "./chunk-PBGO5AFD.js";
+import {
+  CONTEXT_OVERFLOW_ACTIONS,
+  CONTEXT_TOO_LARGE_ACTIONS,
+  isContextOverflowText,
+  performServerProxyFetchWithRetry
+} from "./chunk-IRG4OKY6.js";
+import {
+  createSSEParser,
+  resolveAgentRequiredPackIds,
+  waitForAbortableDelay
+} from "./chunk-DGDGNYI5.js";
+import "./chunk-NF64D32W.js";
+import "./chunk-XPWGOTBQ.js";
+import "./chunk-5XN3OSCT.js";
+import "./chunk-2ECUZDEL.js";
+import "./chunk-6VRWNU5J.js";
+import "./chunk-PFEK4SA2.js";
+import "./chunk-VIDPVFP3.js";
+import "./chunk-AGIM7IMJ.js";
+import "./chunk-X2VPXJZC.js";
+import "./chunk-P6KLYCL3.js";
+import "./chunk-ZJ7UHBJS.js";
+import {
+  clearForegroundTurnSettledVisible,
+  initMsgs,
+  markForegroundTurnSettledVisible,
+  messageStreamEnd,
+  messageStreaming,
+  prepareAndPersistUserMessage,
+  protectTransientForCanonicalHandoff,
+  releaseTransientCanonicalHandoff,
+  removeTransientMessage,
+  resolveHandleSendMessageContext,
+  selectAllMsgs,
+  setMessages,
+  setStreamingMessageId,
+  toolResultNeedsUserConfirmation,
+  updateToolMessage
+} from "./chunk-ROXFUKKL.js";
+import "./chunk-523DITKR.js";
+import "./chunk-UKZX3NHN.js";
+import "./chunk-F2UJW3EK.js";
+import "./chunk-BYXBJQAS.js";
+import "./chunk-QYPE3TS3.js";
+import {
+  streamAgentChatTurn
+} from "./chunk-EXR4XCFE.js";
+import "./chunk-AGGIDPCZ.js";
+import "./chunk-WW2USJ3C.js";
+import "./chunk-5RGU3J7P.js";
+import {
+  addActiveController,
+  getActiveDialogKey,
+  removeActiveController
+} from "./chunk-VBG7GWWR.js";
+import "./chunk-ZRAU6T47.js";
+import "./chunk-4LCOCOR5.js";
+import "./chunk-YDH3FDFQ.js";
+import {
+  selectCurrentServer
+} from "./chunk-QFEW2ULV.js";
+import "./chunk-V2UPLOXT.js";
+import "./chunk-2OMUAIKR.js";
+import "./chunk-UAD2WT54.js";
+import {
+  readAndWait,
+  selectById
+} from "./chunk-RNNWTMKT.js";
+import "./chunk-3PVYUPXK.js";
+import "./chunk-GHZ2H2HJ.js";
+import "./chunk-AIZE5TDM.js";
+import "./chunk-4YRTZIVN.js";
+import "./chunk-UEILX4EV.js";
+import "./chunk-IJERIUXS.js";
+import {
+  getIsDesktopApp
+} from "./chunk-6Q7UTJKR.js";
+import "./chunk-QQ56R7KS.js";
+import "./chunk-OW765XBU.js";
+import {
+  selectIdentityToken,
+  selectIdentityUserId
+} from "./chunk-SEJ5OS6F.js";
+import "./chunk-D2MDMY2M.js";
+import "./chunk-RRQQAG7W.js";
+import {
+  expandEnabledPacks
+} from "./chunk-3CZM6HGQ.js";
+import "./chunk-IXH3HKY2.js";
+import "./chunk-XETG4RIX.js";
+import "./chunk-OKARGYFT.js";
+import "./chunk-JJM3WS6W.js";
+import "./chunk-WJZOQR2J.js";
+import "./chunk-VSPO4S33.js";
+import "./chunk-FWY6BHIJ.js";
+import "./chunk-5MMAK75Q.js";
+import "./chunk-DWLEOOGR.js";
+import "./chunk-PWRS2SU2.js";
+import "./chunk-KX6YBIHG.js";
+import "./chunk-7DPNBQSV.js";
+import {
+  canonicalizeToolName
+} from "./chunk-IHPDK6UD.js";
+import "./chunk-LWLNLZC5.js";
+import "./chunk-3LI5UCTU.js";
+import {
+  extractCustomId
+} from "./chunk-M2EJHDJP.js";
+import {
+  createDialogMessageKeyAndId
+} from "./chunk-RLRYVSCD.js";
+import "./chunk-I42VC5KR.js";
+import "./chunk-U6VC4MU4.js";
+import "./chunk-WWC7I6TA.js";
+import "./chunk-PSCNXBYA.js";
+import "./chunk-NN4UUYGB.js";
+import "./chunk-CGEK73JN.js";
+import "./chunk-W7XHHYWM.js";
+import "./chunk-KUG52IAP.js";
+import "./chunk-3EUW3WEO.js";
+import "./chunk-HNMXYYJR.js";
+import "./chunk-LCBAMY2M.js";
+import "./chunk-4SN6J65J.js";
+import "./chunk-CF7PE763.js";
+import "./chunk-G3SUCT4W.js";
+import "./chunk-P3SFAHIL.js";
+import {
+  PLATFORM_LLM_BUSY_USER_MESSAGE
+} from "./chunk-SZC4REES.js";
+import "./chunk-QSJ3HFEF.js";
+import "./chunk-ZWQUWF6W.js";
+import "./chunk-KHCLMKZZ.js";
+import "./chunk-VEA7H5FG.js";
+import "./chunk-4VJAC32I.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/ai/agent/foregroundTurnStageLog.ts
+var FOREGROUND_TURN_STAGE_LOG_PREFIX = "[foregroundTurn][latency]";
+var isStageLogEnabled = () => {
+  try {
+    if (globalThis.__NOLO_FOREGROUND_TURN_STAGE_LOG__ === true) {
+      return true;
+    }
+    const storage = globalThis.localStorage;
+    return typeof storage?.getItem === "function" ? storage.getItem("nolo.foregroundTurn.stageLog") === "1" : false;
+  } catch {
+    return false;
+  }
+};
+function createForegroundTurnStageLog(args) {
+  const t0 = Date.now();
+  const identity = `turn=${args.turnKey} runId=${args.runId} dialogId=${args.dialogId} dialogKey=${args.dialogKey} base=${args.base}`;
+  const marks = [];
+  return {
+    stage: (stage, detail) => {
+      const at = Date.now() - t0;
+      marks.push(`${stage}=+${at}ms`);
+      if (!isStageLogEnabled()) return;
+      console.info(
+        `${FOREGROUND_TURN_STAGE_LOG_PREFIX} stage=${stage} t=+${at}ms ${identity}${detail ? ` ${detail}` : ""}`
+      );
+    },
+    summary: (outcome, detail) => {
+      console.info(
+        `${FOREGROUND_TURN_STAGE_LOG_PREFIX} SUMMARY outcome=${outcome} total=+${Date.now() - t0}ms ${identity} marks=[${marks.join(" ")}]${detail ? ` ${detail}` : ""}`
+      );
+    }
+  };
+}
+
+// packages/ai/tools/effectiveToolSurface.ts
+function readEffectiveToolName(value) {
+  if (typeof value === "string") {
+    const name2 = canonicalizeToolName(value.trim());
+    return name2 || null;
+  }
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  const candidate = typeof record.name === "string" && record.name || typeof record.toolName === "string" && record.toolName || typeof record.function?.name === "string" && record.function.name || "";
+  const name = canonicalizeToolName(candidate.trim());
+  return name || null;
+}
+function valuesOf(iterable) {
+  return iterable ? [...iterable] : [];
+}
+function resolveEffectiveToolSurface(input) {
+  const agent = input.agent ?? {};
+  const byName = /* @__PURE__ */ new Map();
+  const add = (values, source) => {
+    for (const value of values) {
+      const name = readEffectiveToolName(value);
+      if (!name) continue;
+      let sources = byName.get(name);
+      if (!sources) {
+        sources = /* @__PURE__ */ new Set();
+        byName.set(name, sources);
+      }
+      sources.add(source);
+    }
+  };
+  add(Array.isArray(agent.tools) ? agent.tools : [], "explicit");
+  add(Array.isArray(agent.toolNames) ? agent.toolNames : [], "explicit");
+  const requiredPackIds = resolveAgentRequiredPackIds(agent);
+  add(expandEnabledPacks(requiredPackIds), "required-pack");
+  const policies = [
+    agent.runtimeToolPolicy,
+    agent.runtimeBinding?.runtimeToolPolicy,
+    agent.runtimeBinding?.runtimeToolPolicySnapshot
+  ];
+  for (const policy of policies) {
+    if (!policy || typeof policy !== "object") continue;
+    add(Array.isArray(policy.agentTools) ? policy.agentTools : [], "runtime-policy");
+    add(Array.isArray(policy.runtimeTools) ? policy.runtimeTools : [], "runtime-policy");
+  }
+  add(Array.isArray(agent.referencedTools) ? agent.referencedTools : [], "reference");
+  add(valuesOf(input.referencedToolNames), "reference");
+  add(valuesOf(input.mentionedToolNames), "mention");
+  add(valuesOf(input.hostInjectedToolNames), "host-injected");
+  add(valuesOf(input.runtimeExtraToolNames), "runtime-extra");
+  const disabled = new Set(
+    (Array.isArray(agent.disabledTools) ? agent.disabledTools : []).map(readEffectiveToolName).filter((name) => !!name)
+  );
+  for (const name of disabled) byName.delete(name);
+  const entries = [...byName.entries()].map(
+    ([name, sources]) => ({ name, sources: [...sources] })
+  );
+  const requestedSources = /* @__PURE__ */ new Set([
+    "explicit",
+    "required-pack",
+    "runtime-policy",
+    "reference",
+    "mention",
+    "runtime-extra"
+  ]);
+  const requestedNames = entries.filter((entry) => entry.sources.some((source) => requestedSources.has(source))).map((entry) => entry.name);
+  const hostInjectedNames = entries.filter((entry) => entry.sources.includes("host-injected")).map((entry) => entry.name);
+  const shellEnabled = policies.some(
+    (policy) => policy && typeof policy === "object" && policy.shell?.enabled === true
+  );
+  const workspaceModes = [
+    ...new Set(
+      policies.map(
+        (policy) => policy && typeof policy === "object" && typeof policy.workspace?.mode === "string" ? policy.workspace.mode.trim() : ""
+      ).filter(Boolean)
+    )
+  ];
+  return {
+    names: entries.map((entry) => entry.name),
+    entries,
+    requestedNames,
+    hostInjectedNames,
+    shellEnabled,
+    workspaceModes,
+    workspaceLease: workspaceModes.includes("lease")
+  };
+}
+
+// packages/ai/tools/toolExecutionSemantics.ts
+var UNKNOWN_TOOL_EXECUTION_CONTRACT = {
+  replay: "unknown",
+  sideEffects: "unknown",
+  locality: "unknown",
+  interaction: "unknown",
+  concurrency: "exclusive",
+  durableWebForeground: false
+};
+var serverPureRead = (durableWebForeground) => ({
+  replay: "pure",
+  sideEffects: "none",
+  locality: "server",
+  interaction: "none",
+  concurrency: "safe",
+  durableWebForeground
+});
+var serverExternalRead = (durableWebForeground) => ({
+  // Repeating the request should not mutate the target resource, but may spend
+  // provider quota/money and may observe newer remote state; it is not pure.
+  replay: "idempotent",
+  sideEffects: "observable",
+  locality: "server",
+  interaction: "none",
+  concurrency: "safe",
+  durableWebForeground
+});
+var serverConfirmedHandoffStep = () => ({
+  replay: "unsafe",
+  sideEffects: "observable",
+  locality: "server",
+  interaction: "handoff",
+  concurrency: "exclusive",
+  durableWebForeground: false
+});
+var TOOL_EXECUTION_CONTRACT = Object.freeze({
+  // Proven durable network reads. They execute on the server but touch external
+  // systems, so replay/cost semantics are intentionally not called "pure".
+  exa_search: serverExternalRead("read-only"),
+  fetchWebpage: serverExternalRead("read-only"),
+  // Proven durable server-hosted workspace reads/queries.
+  searchDialogMessages: serverPureRead("read-only"),
+  listDialogs: serverPureRead("read-only"),
+  readDialog: serverPureRead("read-only"),
+  queryDialogsBySubjectRef: serverPureRead("read-only"),
+  listAgents: serverPureRead("read-only"),
+  readAgent: serverPureRead("read-only"),
+  listSpaces: serverPureRead("read-only"),
+  readSpace: serverPureRead("read-only"),
+  readDoc: serverPureRead("read-only"),
+  readSkillDoc: serverPureRead("read-only"),
+  listTables: serverPureRead("read-only"),
+  queryTableRows: serverPureRead("read-only"),
+  // Read-only presentation payload. Actions remain inert; this adds no submit or
+  // open-app authority to server-owned projection.
+  show_interaction: {
+    replay: "pure",
+    sideEffects: "none",
+    locality: "server",
+    interaction: "none",
+    concurrency: "safe",
+    durableWebForeground: "read-only"
+  },
+  // Durable interactive boundary: the current execution ends and a later user
+  // choice starts a new execution. It is intentionally not modeled as a read.
+  ask_user: {
+    replay: "unsafe",
+    sideEffects: "observable",
+    locality: "server",
+    interaction: "blocking",
+    concurrency: "exclusive",
+    durableWebForeground: "interactive"
+  },
+  // Confirmed human hand-off boundary for the media step family. These tools
+  // do not start work needing authorization: they return
+  // `{ status: "requires_confirmation", ... }` and the run must stop and wait
+  // for the user. Registered explicitly (rather than inferred from any status)
+  // so a random tool echoing the same status never pauses the run, and kept out
+  // of the durable Web foreground plane on purpose (media ServerTool admission
+  // is owned elsewhere).
+  transcribe: serverConfirmedHandoffStep(),
+  translate: serverConfirmedHandoffStep(),
+  exportDocument: serverConfirmedHandoffStep(),
+  readArtifact: serverConfirmedHandoffStep(),
+  // Representative explicitly non-durable execution classes. These entries
+  // make the reason machine-readable; unlisted tools remain UNKNOWN.
+  execShell: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "workspace",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  readFile: {
+    replay: "idempotent",
+    sideEffects: "none",
+    locality: "device",
+    interaction: "none",
+    concurrency: "safe",
+    durableWebForeground: false
+  },
+  globFiles: {
+    replay: "idempotent",
+    sideEffects: "none",
+    locality: "device",
+    interaction: "none",
+    concurrency: "safe",
+    durableWebForeground: false
+  },
+  createDoc: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  updateDoc: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  deleteDialogs: {
+    replay: "unsafe",
+    sideEffects: "mutation",
+    locality: "server",
+    interaction: "confirm",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  },
+  loadSkill: {
+    replay: "unsafe",
+    sideEffects: "observable",
+    locality: "server",
+    interaction: "none",
+    concurrency: "exclusive",
+    durableWebForeground: false
+  }
+});
+function resolveToolExecutionContract(toolName) {
+  if (typeof toolName !== "string" || !toolName.trim()) {
+    return UNKNOWN_TOOL_EXECUTION_CONTRACT;
+  }
+  const canonicalName = canonicalizeToolName(toolName);
+  return TOOL_EXECUTION_CONTRACT[canonicalName] ?? UNKNOWN_TOOL_EXECUTION_CONTRACT;
+}
+function collectDurableWebToolNames(durableClass) {
+  return new Set(
+    Object.entries(TOOL_EXECUTION_CONTRACT).filter(([, contract]) => contract.durableWebForeground === durableClass).map(([name]) => name)
+  );
+}
+var DURABLE_WEB_FOREGROUND_READ_ONLY_TOOL_NAMES = collectDurableWebToolNames("read-only");
+var DURABLE_WEB_FOREGROUND_INTERACTIVE_TOOL_NAMES = collectDurableWebToolNames("interactive");
+var DURABLE_WEB_FOREGROUND_TOOL_NAMES = /* @__PURE__ */ new Set([
+  ...DURABLE_WEB_FOREGROUND_READ_ONLY_TOOL_NAMES,
+  ...DURABLE_WEB_FOREGROUND_INTERACTIVE_TOOL_NAMES
+]);
+var CONFIRMED_HANDOFF_TOOL_NAMES = new Set(
+  Object.entries(TOOL_EXECUTION_CONTRACT).filter(([, contract]) => contract.interaction === "handoff").map(([name]) => name)
+);
+function hasProvenServerReadOnlySemantics(toolName) {
+  const contract = resolveToolExecutionContract(toolName);
+  return contract.durableWebForeground === "read-only" && (contract.replay === "pure" || contract.replay === "idempotent") && (contract.sideEffects === "none" || contract.sideEffects === "observable") && contract.locality === "server" && contract.interaction === "none";
+}
+function hasProvenDurableWebForegroundSemantics(toolName) {
+  const contract = resolveToolExecutionContract(toolName);
+  if (contract.durableWebForeground === "read-only") {
+    return hasProvenServerReadOnlySemantics(toolName);
+  }
+  if (contract.durableWebForeground === "interactive") {
+    return contract.locality === "server" && contract.interaction === "blocking" && contract.sideEffects === "observable";
+  }
+  return false;
+}
+
+// packages/ai/agent/serverOwnedWebForegroundEligibility.ts
+var AUDITED_WEB_FOREGROUND_HOST_BASELINE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  // TOOL_PACKS.CORE
+  "read",
+  "readFile",
+  "createDoc",
+  "updateDoc",
+  "search_workspace",
+  "updateSelf",
+  "ask_user",
+  // show_interaction: CORE 宿主注入；服务端纯函数展示（parse + fallback，无 I/O、无客户端通道），只读展示语义，不执行卡片动作
+  "show_interaction",
+  "createAgentAutomation",
+  "updateAgentAutomation",
+  "deleteAgentAutomation",
+  "notifyUser",
+  // ALWAYS_ON_PACK_IDS: long-term-memory + skills
+  "queryMemory",
+  "rememberMemory",
+  "deleteMemory",
+  "loadSkill",
+  "readSkillDoc",
+  // Default system capabilities
+  "exa_search",
+  "fetchWebpage",
+  "startAgentRun",
+  "controlAgentRun",
+  "listAgents"
+]);
+function isDurableRequestedToolName(name) {
+  if (typeof name !== "string") return false;
+  return hasProvenDurableWebForegroundSemantics(canonicalizeToolName(name));
+}
+function hasSupportedDurableToolSurface(agent, suppliedSurface) {
+  const surface = suppliedSurface ?? resolveEffectiveToolSurface({
+    agent
+  });
+  if (surface.shellEnabled || surface.workspaceLease) return false;
+  if (!surface.requestedNames.every(isDurableRequestedToolName)) {
+    return false;
+  }
+  return surface.hostInjectedNames.every(
+    (name) => AUDITED_WEB_FOREGROUND_HOST_BASELINE_TOOL_NAMES.has(canonicalizeToolName(name))
+  );
+}
+function shouldUseServerOwnedWebForegroundTurn(input) {
+  if (input.surface !== "web") return false;
+  if (input.isDesktopApp) return false;
+  if (!input.currentServer?.trim() || !input.token?.trim()) return false;
+  if (typeof input.userInput !== "string" || !input.userInput.trim()) return false;
+  if (input.turnToolContext) {
+    if (!input.turnToolContext.complete) return false;
+    if (input.turnToolContext.unresolvedReasons?.length) return false;
+    if (!input.effectiveToolSurface) {
+      const lateBound = [
+        ...input.turnToolContext.referencedToolNames,
+        ...input.turnToolContext.mentionedToolNames
+      ];
+      if (lateBound.some((name) => !isDurableRequestedToolName(name))) {
+        return false;
+      }
+    }
+  }
+  const agent = input.agentConfig;
+  if (!agent) return false;
+  if (agent.useServerProxy === false) return false;
+  if (agent.apiSource === "cli") return false;
+  if (agent.runtimeBinding?.machineId) return false;
+  if (!hasSupportedDurableToolSurface(agent, input.effectiveToolSurface)) return false;
+  const runtimeOptions = input.runtimeOptions;
+  if (runtimeOptions?.extraTools?.length) {
+    if (!input.effectiveToolSurface) return false;
+    if (runtimeOptions.extraTools.some((name) => !isDurableRequestedToolName(name))) {
+      return false;
+    }
+  }
+  if (runtimeOptions?.editingTarget) return false;
+  if (runtimeOptions?.imageConfigOverride) return false;
+  if (runtimeOptions?.quickChatModelOverride) return false;
+  if (runtimeOptions?.workspaceToolsHint) return false;
+  if (runtimeOptions?.cwd) return false;
+  if (runtimeOptions?.restrictShellToWorkspace) return false;
+  return true;
+}
+
+// packages/ai/agent/serverOwnedToolProjection.ts
+function parseToolArgs(raw) {
+  if (typeof raw !== "string" || !raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function normalizeToolSet(values) {
+  return new Set(
+    [...values].map((value) => canonicalizeToolName(value)).filter(Boolean)
+  );
+}
+function isToolResultFailure(content, metadata) {
+  if (metadata?.error) return true;
+  if (typeof content !== "string" || !content.trim()) return false;
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
+    const record = parsed;
+    return Boolean(record.error) || record.ok === false || record.success === false || record.status === "error";
+  } catch {
+    return false;
+  }
+}
+function createServerOwnedToolProjection(args) {
+  const supported = normalizeToolSet(args.supportedToolNames);
+  const keepReadOnly = normalizeToolSet(args.keepReadOnlyUntilCanonical ?? []);
+  const transientByCallId = /* @__PURE__ */ new Map();
+  const handlePayload = (payload) => {
+    if (!payload || typeof payload !== "object") return;
+    if (payload.type === "assistant_tool_calls") {
+      const calls = Array.isArray(payload.tool_calls) ? payload.tool_calls : [];
+      for (const call of calls) {
+        const callId2 = typeof call?.id === "string" ? call.id : "";
+        const toolName2 = canonicalizeToolName(call?.function?.name ?? "");
+        if (!callId2 || !toolName2 || !supported.has(toolName2)) continue;
+        if (transientByCallId.has(callId2)) continue;
+        const { key, messageId } = createDialogMessageKeyAndId(args.dialogId);
+        const input = parseToolArgs(call?.function?.arguments);
+        const content2 = toolName2 === "ask_user" ? JSON.stringify({ type: "ask_user", ...input }) : "";
+        const message2 = {
+          id: messageId,
+          dialogId: args.dialogId,
+          dbKey: key,
+          role: "tool",
+          content: content2,
+          isStreaming: true,
+          toolName: toolName2,
+          toolCallId: callId2,
+          toolPayload: {
+            toolName: toolName2,
+            status: "running",
+            input,
+            rawToolCall: call,
+            summary: ""
+          },
+          ...args.messageMetadata
+        };
+        transientByCallId.set(callId2, message2);
+        args.dispatch(messageStreaming(message2));
+      }
+      return;
+    }
+    if (payload.type !== "tool_result") return;
+    const callId = typeof payload.toolCallId === "string" ? payload.toolCallId : "";
+    if (!callId) return;
+    const existing = transientByCallId.get(callId);
+    const toolName = canonicalizeToolName(payload.toolName ?? existing?.toolName ?? "");
+    if (!toolName || !supported.has(toolName)) return;
+    const metadata = payload.metadata && typeof payload.metadata === "object" && !Array.isArray(payload.metadata) ? payload.metadata : void 0;
+    const failed = isToolResultFailure(payload.content, metadata);
+    const content = toolName === "ask_user" ? typeof payload.content === "string" ? payload.content : "" : projectDesktopToolUiContent({ toolName, content: payload.content, metadata });
+    const base = existing ?? (() => {
+      const { key, messageId } = createDialogMessageKeyAndId(args.dialogId);
+      return {
+        id: messageId,
+        dialogId: args.dialogId,
+        dbKey: key,
+        role: "tool",
+        content: "",
+        isStreaming: true,
+        toolName,
+        toolCallId: callId,
+        toolPayload: {
+          toolName,
+          status: "running",
+          input: {},
+          summary: ""
+        },
+        ...args.messageMetadata
+      };
+    })();
+    const staysReadOnly = !failed && keepReadOnly.has(toolName);
+    const awaitingUserConfirmation = toolResultNeedsUserConfirmation(toolName, payload.content);
+    const toolPayload = {
+      ...base.toolPayload ?? {},
+      toolName,
+      status: staysReadOnly ? "running" : awaitingUserConfirmation ? "pending" : failed ? "failed" : "succeeded"
+    };
+    const message = {
+      ...base,
+      content,
+      isStreaming: staysReadOnly,
+      toolName,
+      // F1: surface server-projected metadata (incl. executionLocation) on the
+      // message so tool rows can render the actual execution host.
+      ...metadata ? { metadata } : {},
+      toolPayload
+    };
+    transientByCallId.set(callId, message);
+    if (staysReadOnly) {
+      args.dispatch(messageStreaming(message));
+      return;
+    }
+    if (!existing) {
+      args.dispatch(messageStreaming(base));
+    }
+    args.dispatch(
+      updateToolMessage({
+        id: base.id,
+        dialogId: args.dialogId,
+        changes: {
+          content,
+          isStreaming: false,
+          toolName,
+          toolPayload,
+          ...metadata ? { metadata } : {}
+        }
+      })
+    );
+  };
+  const cleanup = () => {
+    for (const message of transientByCallId.values()) {
+      args.dispatch(removeTransientMessage({ id: message.id, dialogId: args.dialogId }));
+    }
+    transientByCallId.clear();
+  };
+  return { handlePayload, cleanup, transientByCallId };
+}
+
+// packages/ai/agent/serverOwnedWebForegroundHandoff.ts
+function normalizeComparableText(value) {
+  if (typeof value === "string") {
+    return value.replace(/\r\n/g, "\n").trimEnd();
+  }
+  if (!Array.isArray(value)) return "";
+  return value.flatMap((part) => {
+    if (!part || typeof part !== "object") return [];
+    const record = part;
+    if (record.type === "text" && typeof record.text === "string") {
+      return [record.text];
+    }
+    return [];
+  }).join("").replace(/\r\n/g, "\n").trimEnd();
+}
+function assistantText(message) {
+  return normalizeComparableText(message.content);
+}
+function assistantThinking(message) {
+  const value = typeof message.thinkContent === "string" ? message.thinkContent : typeof message.reasoning_content === "string" ? message.reasoning_content : "";
+  return normalizeComparableText(value);
+}
+function assistantAgentKey(message) {
+  const value = message.agentKey ?? message.cybotKey;
+  return typeof value === "string" ? value : "";
+}
+function findNewCanonicalAssistant(messages, initialMessageIds, transientId, expectedText, expectedThinking, expectedAgentKey) {
+  const transient = messages.find((message) => message?.id === transientId);
+  const completedText = normalizeComparableText(
+    expectedText !== void 0 ? expectedText : transient ? assistantText(transient) : ""
+  );
+  const completedThinking = normalizeComparableText(
+    expectedThinking !== void 0 ? expectedThinking : transient ? assistantThinking(transient) : ""
+  );
+  const candidates = messages.filter((message) => {
+    if (!message?.id || message.id === transientId) return false;
+    if (initialMessageIds.has(message.id)) return false;
+    if (message.role !== "assistant") return false;
+    if (message.isStreaming) return false;
+    if (completedText) return assistantText(message) === completedText;
+    if (completedThinking) return assistantThinking(message) === completedThinking;
+    return false;
+  });
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0] ?? null;
+  if (expectedAgentKey) {
+    const agentMatches = candidates.filter(
+      (message) => assistantAgentKey(message) === expectedAgentKey
+    );
+    if (agentMatches.length === 1) return agentMatches[0] ?? null;
+  }
+  return null;
+}
+async function waitForNewCanonicalAssistant(args) {
+  const timeoutMs = Math.max(0, args.timeoutMs ?? 5e3);
+  const pollMs = Math.max(1, args.pollMs ?? 25);
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const canonical = findNewCanonicalAssistant(
+      args.readMessages(),
+      args.initialMessageIds,
+      args.transientId,
+      args.expectedText,
+      args.expectedThinking,
+      args.expectedAgentKey
+    );
+    if (canonical) return canonical;
+    if (Date.now() >= deadline) return null;
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+}
+
+// packages/ai/agent/serverOwnedWebEffectiveToolSurface.ts
+function resolveServerOwnedWebEffectiveToolSurface(args) {
+  const referencedToolNames = args.turnToolContext?.referencedToolNames ?? [];
+  const mentionedToolNames = args.turnToolContext?.mentionedToolNames ?? [];
+  const requested = resolveEffectiveToolSurface({
+    agent: args.agentConfig,
+    referencedToolNames,
+    mentionedToolNames,
+    runtimeExtraToolNames: args.runtimeOptions?.extraTools ?? []
+  });
+  const mergedAgent = mergeAgentToolsWithRuntime(
+    args.agentConfig,
+    referencedToolNames,
+    mentionedToolNames,
+    args.runtimeOptions ?? void 0,
+    args.state
+  );
+  const rawNames = (Array.isArray(mergedAgent.tools) ? mergedAgent.tools : []).map(readEffectiveToolName).filter((name) => typeof name === "string" && !!name);
+  const finalNames = Array.from(new Set(rawNames));
+  const finalSet = new Set(finalNames);
+  const requestedSet = new Set(requested.requestedNames);
+  const requestedNames = requested.requestedNames.filter((name) => finalSet.has(name));
+  const hostInjectedNames = finalNames.filter((name) => !requestedSet.has(name));
+  const hostResolved = resolveEffectiveToolSurface({
+    agent: args.agentConfig,
+    referencedToolNames,
+    mentionedToolNames,
+    hostInjectedToolNames: hostInjectedNames,
+    runtimeExtraToolNames: args.runtimeOptions?.extraTools ?? []
+  });
+  const entryByName = new Map(hostResolved.entries.map((entry) => [entry.name, entry]));
+  const entries = finalNames.flatMap((name) => {
+    const entry = entryByName.get(name);
+    return entry ? [entry] : [];
+  });
+  return {
+    names: finalNames,
+    entries,
+    requestedNames,
+    hostInjectedNames,
+    shellEnabled: hostResolved.shellEnabled,
+    workspaceModes: hostResolved.workspaceModes,
+    workspaceLease: hostResolved.workspaceLease
+  };
+}
+
+// packages/ai/agent/serverOwnedAssistantStream.ts
+var EMPTY_SERVER_OWNED_ASSISTANT_STREAM = {
+  text: "",
+  thinking: "",
+  segmentText: "",
+  segmentThinking: ""
+};
+function applyServerOwnedAssistantStreamPayload(state, payload) {
+  if (payload?.type === "thinking" && typeof payload.content === "string") {
+    return {
+      ...state,
+      thinking: state.thinking + payload.content,
+      segmentThinking: state.segmentThinking + payload.content
+    };
+  }
+  if (payload?.type === "text" && typeof payload.content === "string") {
+    return {
+      ...state,
+      text: state.text + payload.content,
+      segmentText: state.segmentText + payload.content
+    };
+  }
+  if (payload?.type === "assistant_tool_calls") {
+    if (!state.segmentText && !state.segmentThinking) return state;
+    return {
+      ...state,
+      segmentText: "",
+      segmentThinking: ""
+    };
+  }
+  return state;
+}
+
+// packages/ai/agent/serverOwnedWebForegroundTurn.ts
+var SERVER_OWNED_CANONICAL_HANDOFF_PROTECT_MS = 65e3;
+function resolveServerOwnedWebAllowedToolNames(toolNames) {
+  return Array.from(
+    new Set(
+      toolNames.filter((name) => typeof name === "string").map((name) => canonicalizeToolName(name)).filter((name) => DURABLE_WEB_FOREGROUND_TOOL_NAMES.has(name))
+    )
+  );
+}
+function detectServerOwnedCandidateSurface() {
+  return typeof window !== "undefined" && typeof document !== "undefined" ? "web" : "non-web";
+}
+async function canRunServerOwnedWebForegroundTurn(args, thunk) {
+  try {
+    let state;
+    let currentServer;
+    let token;
+    try {
+      state = thunk.getState();
+      currentServer = selectCurrentServer(state);
+      const rawToken = selectIdentityToken(state);
+      token = typeof rawToken === "string" ? rawToken : void 0;
+    } catch {
+      return { eligible: false };
+    }
+    if (!currentServer?.trim() || !token?.trim()) return { eligible: false };
+    let agentConfig = args.agentConfig ?? void 0;
+    if (!agentConfig) {
+      try {
+        const { readAndWait: readAndWait2 } = await import("./dbSlice-JQFBMJ55.js");
+        agentConfig = await thunk.dispatch(readAndWait2(args.agentKey)).unwrap();
+      } catch {
+        return { eligible: false };
+      }
+    }
+    if (!agentConfig) return { eligible: false };
+    const turnToolContext = await resolveTurnToolContext({
+      agentConfig,
+      dialogConfig: args.dialogConfig,
+      userInput: args.userInput,
+      state,
+      dispatch: thunk.dispatch,
+      runtimeOptions: args.runtimeOptions
+    });
+    const effectiveToolSurface = resolveServerOwnedWebEffectiveToolSurface({
+      agentConfig,
+      runtimeOptions: args.runtimeOptions,
+      state,
+      turnToolContext
+    });
+    const eligible = shouldUseServerOwnedWebForegroundTurn({
+      surface: detectServerOwnedCandidateSurface(),
+      agentConfig,
+      effectiveToolSurface,
+      turnToolContext,
+      userInput: args.userInput,
+      runtimeOptions: args.runtimeOptions,
+      currentServer,
+      token,
+      isDesktopApp: getIsDesktopApp()
+    });
+    if (!eligible) {
+      return { eligible: false, agentConfig };
+    }
+    return {
+      eligible: true,
+      agentConfig: {
+        ...agentConfig,
+        tools: resolveServerOwnedWebAllowedToolNames(effectiveToolSurface.names)
+      }
+    };
+  } catch {
+    return { eligible: false };
+  }
+}
+async function runServerOwnedWebForegroundTurn(args, thunk) {
+  const state = thunk.getState();
+  const currentServer = String(selectCurrentServer(state) ?? "").replace(/\/+$/, "");
+  const token = selectIdentityToken(state);
+  if (!currentServer || !token) {
+    throw new Error("Server-owned foreground turn requires an authenticated server");
+  }
+  const dialogKey = args.dialogConfig.dbKey;
+  const dialogId = args.dialogConfig.id ?? (dialogKey ? extractCustomId(dialogKey) : "");
+  if (!dialogId || !dialogKey) {
+    throw new Error("Server-owned foreground turn requires an existing dialog");
+  }
+  const userInput = typeof args.userInput === "string" ? args.userInput : "";
+  if (!userInput.trim()) {
+    throw new Error("Server-owned foreground turn requires text input");
+  }
+  const initialMessageIds = new Set(
+    selectAllMsgs(thunk.getState(), dialogId).map((message) => message?.id).filter((id) => typeof id === "string" && id.length > 0)
+  );
+  const userId = selectIdentityUserId(thunk.getState());
+  const { key: transientKey, messageId: transientId } = createDialogMessageKeyAndId(dialogId);
+  const controller = new AbortController();
+  const loopKey = `server-owned:${dialogId}:${transientId}`;
+  let assistantStream = EMPTY_SERVER_OWNED_ASSISTANT_STREAM;
+  let sawDone = false;
+  let clientControllerReleased = false;
+  let visibleFinalized = false;
+  let sawFirstDelta = false;
+  let observedExecutionId = "";
+  let canonicalVisible = false;
+  const stageLog = createForegroundTurnStageLog({
+    turnKey: loopKey,
+    // This path's server run identity IS the dialogId; executionId stays in the
+    // SUMMARY detail to tell multiple runs of the same dialog apart.
+    runId: dialogId,
+    dialogKey,
+    dialogId,
+    base: currentServer
+  });
+  const toolProjection = createServerOwnedToolProjection({
+    dialogId,
+    dispatch: thunk.dispatch,
+    messageMetadata: {
+      cybotKey: args.agentKey,
+      agentKey: args.agentKey,
+      userId
+    },
+    supportedToolNames: DURABLE_WEB_FOREGROUND_TOOL_NAMES,
+    keepReadOnlyUntilCanonical: ["ask_user", "show_interaction"]
+  });
+  const projectAssistant = () => {
+    thunk.dispatch(
+      messageStreaming({
+        id: transientId,
+        dialogId,
+        dbKey: transientKey,
+        role: "assistant",
+        content: assistantStream.text,
+        thinkContent: assistantStream.thinking,
+        cybotKey: args.agentKey,
+        agentKey: args.agentKey,
+        userId
+      })
+    );
+  };
+  const releaseClientController = () => {
+    if (clientControllerReleased) return;
+    clientControllerReleased = true;
+    thunk.dispatch(removeActiveController({ messageId: loopKey, dialogKey }));
+    clearForegroundTurnSettledVisible(dialogId);
+    stageLog.stage("controller-release");
+  };
+  const finalizeVisibleProjectionOnDone = () => {
+    if (visibleFinalized) return;
+    visibleFinalized = true;
+    protectTransientForCanonicalHandoff(
+      dialogId,
+      transientId,
+      SERVER_OWNED_CANONICAL_HANDOFF_PROTECT_MS
+    );
+    finishTransientImmediately();
+    markForegroundTurnSettledVisible(dialogId);
+  };
+  const finishTransientImmediately = () => {
+    const transient = selectAllMsgs(thunk.getState(), dialogId).find((message) => message?.id === transientId);
+    if (transient) {
+      thunk.dispatch(
+        setMessages({
+          dialogId,
+          messages: [{
+            ...transient,
+            content: assistantStream.text,
+            thinkContent: assistantStream.thinking,
+            isStreaming: false
+          }]
+        })
+      );
+    }
+    setStreamingMessageId(dialogId, null);
+  };
+  const removeTransientWhenCanonicalArrives = () => {
+    void waitForNewCanonicalAssistant({
+      readMessages: () => selectAllMsgs(thunk.getState(), dialogId),
+      initialMessageIds,
+      transientId,
+      // The server persists a new assistant trace segment after every tool
+      // boundary. Fingerprint only the final segment here; the live transient
+      // intentionally keeps the concatenated presentation until canonical rows
+      // replace it.
+      expectedText: assistantStream.segmentText,
+      expectedThinking: assistantStream.segmentThinking,
+      expectedAgentKey: args.agentKey,
+      timeoutMs: 6e4,
+      pollMs: 100
+    }).then((canonical) => {
+      if (!canonical) return;
+      toolProjection.cleanup();
+      thunk.dispatch(removeTransientMessage({ id: transientId, dialogId }));
+    }).catch(() => {
+    }).finally(() => {
+      releaseTransientCanonicalHandoff(dialogId, transientId);
+    });
+  };
+  thunk.dispatch(addActiveController({ messageId: loopKey, controller, dialogKey }));
+  projectAssistant();
+  const allowedToolNames = resolveServerOwnedWebAllowedToolNames(
+    Array.isArray(args.agentConfig.tools) ? args.agentConfig.tools : []
+  );
+  const body = JSON.stringify({
+    agentKey: args.agentKey,
+    userInput,
+    stream: true,
+    persistDialog: true,
+    continueDialogId: dialogId,
+    runtimeContext: {
+      surface: "web",
+      host: "browser",
+      runtime: "react",
+      entrypoint: "chat-dialog-server-owned",
+      capabilities: [
+        "streaming",
+        "dialog-ui",
+        "durable-foreground",
+        "client-user-prepersisted",
+        "durable-tool-cards"
+      ],
+      // This is the exact post-filter surface produced during admission, not a
+      // global durable superset. Server-private defaults and machine tools are
+      // injected before this constraint, then intersected back to this turn's
+      // admitted names. Direct run() callers are sanitized again above.
+      allowedToolNames,
+      ...args.dialogConfig.agentMode === "auto" ? { dialogAgentMode: "auto" } : { dialogAgentMode: "fixed" }
+    },
+    ...args.runtimeOptions ? { runtimeOptions: args.runtimeOptions } : {},
+    ...args.contextBlocks?.length ? { contextBlocks: args.contextBlocks } : {},
+    ...args.dialogConfig.spaceId ? { spaceId: args.dialogConfig.spaceId } : {}
+  });
+  const init = buildForegroundTurnAdmissionFetchInit({
+    body,
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "text/event-stream",
+      Authorization: `Bearer ${token}`
+    },
+    signal: controller.signal
+  });
+  stageLog.stage(
+    "run-fetch-start",
+    `endpoint=${currentServer}/api/agent/run agentKey=${args.agentKey}`
+  );
+  try {
+    let response;
+    try {
+      response = await performServerProxyFetchWithRetry({
+        execute: () => fetch(`${currentServer}/api/agent/run`, init),
+        signal: controller.signal,
+        retryNetworkErrors: false,
+        logPrefix: "[serverOwnedWebForegroundTurn]"
+      });
+    } catch (error) {
+      if (controller.signal.aborted) return { serverOwned: true, aborted: true };
+      console.warn("[chat] server-owned foreground detached before response", {
+        dialogId,
+        error
+      });
+      return { serverOwned: true, detached: true };
+    }
+    stageLog.stage("headers", `status=${response.status} ok=${response.ok}`);
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(text || `Agent run failed (${response.status})`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      stageLog.stage("no-stream-body");
+      return { serverOwned: true, detached: true };
+    }
+    const parseSSE = createSSEParser();
+    const decoder = new TextDecoder();
+    const outcome = await consumeAgentRunStream({
+      reader,
+      decoder,
+      parseChunk: (raw) => parseSSE(raw),
+      isAborted: () => controller.signal.aborted,
+      signal: controller.signal,
+      isDoneEvent: (payload) => payload?.type === "done",
+      onAbort: async () => {
+      },
+      onPayload: (payload) => {
+        if (payload?.type === "dialog") {
+          observedExecutionId = typeof payload.executionId === "string" ? payload.executionId.trim() : "";
+        }
+        if (payload?.type === "error") {
+          return { reject: payload.message || "Agent execution failed" };
+        }
+        toolProjection.handlePayload(payload);
+        const nextAssistantStream = applyServerOwnedAssistantStreamPayload(
+          assistantStream,
+          payload
+        );
+        if (nextAssistantStream !== assistantStream) {
+          assistantStream = nextAssistantStream;
+          projectAssistant();
+          if (!sawFirstDelta && payload?.type !== "done") {
+            sawFirstDelta = true;
+            stageLog.stage(
+              "first-delta",
+              `payloadType=${payload?.type} executionId=${observedExecutionId}`
+            );
+          }
+        }
+        if (payload?.type === "done" && !visibleFinalized) {
+          stageLog.stage("done-frame", `executionId=${observedExecutionId}`);
+          finalizeVisibleProjectionOnDone();
+        }
+      }
+    });
+    stageLog.stage(
+      "eof",
+      outcome.outcome === "streamEnded" ? `outcome=streamEnded sawDone=${outcome.sawDone} executionId=${observedExecutionId}` : `outcome=${outcome.outcome}`
+    );
+    if (outcome.outcome === "aborted") return { serverOwned: true, aborted: true };
+    if (outcome.outcome === "rejected") throw new Error(outcome.message);
+    if (!outcome.sawDone) return { serverOwned: true, detached: true };
+    sawDone = true;
+    finalizeVisibleProjectionOnDone();
+    try {
+      stageLog.stage("init-msgs-start", `dialogKey=${dialogKey}`);
+      const initMsgsStartedAt = Date.now();
+      await thunk.dispatch(
+        initMsgs({
+          dialogId,
+          dialogKey,
+          preferredServerOrigin: currentServer
+        })
+      ).unwrap();
+      stageLog.stage("init-msgs-end", `ms=${Date.now() - initMsgsStartedAt}`);
+      canonicalVisible = !!await waitForNewCanonicalAssistant({
+        readMessages: () => selectAllMsgs(thunk.getState(), dialogId),
+        initialMessageIds,
+        transientId,
+        expectedText: assistantStream.segmentText,
+        expectedThinking: assistantStream.segmentThinking,
+        expectedAgentKey: args.agentKey,
+        timeoutMs: 350,
+        pollMs: 25
+      });
+    } catch (error) {
+      console.warn("[chat] server-owned canonical handoff refresh failed", {
+        dialogId,
+        error
+      });
+    }
+    if (canonicalVisible) {
+      releaseTransientCanonicalHandoff(dialogId, transientId);
+      toolProjection.cleanup();
+      thunk.dispatch(removeTransientMessage({ id: transientId, dialogId }));
+    } else {
+      toolProjection.cleanup();
+      removeTransientWhenCanonicalArrives();
+      console.warn(
+        "[chat] server-owned canonical message not visible after done; keeping finished transient until canonical arrives",
+        { dialogId, transientId }
+      );
+    }
+    return { serverOwned: true };
+  } finally {
+    releaseClientController();
+    if (!sawDone && !visibleFinalized) {
+      releaseTransientCanonicalHandoff(dialogId, transientId);
+      toolProjection.cleanup();
+      thunk.dispatch(removeTransientMessage({ id: transientId, dialogId }));
+    }
+    if (visibleFinalized && !sawDone) {
+      toolProjection.cleanup();
+      removeTransientWhenCanonicalArrives();
+    }
+    stageLog.summary(
+      controller.signal.aborted ? "aborted" : sawDone ? "done" : visibleFinalized ? "done-visible-only" : "no-done",
+      `runId=${dialogId} executionId=${observedExecutionId} canonicalVisible=${canonicalVisible} settledVisible=${visibleFinalized}`
+    );
+  }
+}
+
+// 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 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) {
+  return scanValidationDetails(details);
+}
+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);
+  const inputRecord = asRecord(errorInput);
+  const authCode = asString(inputRecord?.authCode) ?? asString(inputRecord?.code);
+  const hasPlatformAuthCode = /^AUTH_[A-Z0-9_]+$/.test(authCode ?? "") || /\bAUTH_[A-Z0-9_]+\b/.test(fullErrorText);
+  const isPlatformProviderFailure = /\bplatform provider failed\b/i.test(fullErrorText);
+  const isLoginStatus = statusCode === void 0 || statusCode === 401;
+  const requiresLogin = isLoginStatus && !url && !/validation_required|api[_ -]?key/i.test(fullErrorText) && (hasPlatformAuthCode || isPlatformProviderFailure && statusCode === 401);
+  if (requiresLogin) {
+    return {
+      kind: "auth",
+      retryable: false,
+      stage,
+      summary: "\u9700\u8981\u767B\u5F55",
+      actionHint: "\u672A\u68C0\u6D4B\u5230\u767B\u5F55\u72B6\u6001\uFF0C\u8BF7\u5148\u767B\u5F55",
+      extraLinks: [{ text: "\u53BB\u767B\u5F55", url: "/login" }]
+    };
+  }
+  const isPlatformBusy = fullErrorText.includes(PLATFORM_LLM_BUSY_USER_MESSAGE) || /PLATFORM_LLM_BUSY/i.test(fullErrorText);
+  const busyUpstreamDetail = fullErrorText.match(
+    /nolo\s+(?:HTTP\s*\d{3}|[A-Za-z]+Error)/
+  )?.[0];
+  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
+  );
+  const isContextOverflow = isContextOverflowText(fullErrorText);
+  let contextActions;
+  if (isContextOverflow) {
+    kind = "context_overflow";
+    retryable = true;
+    contextActions = [...CONTEXT_OVERFLOW_ACTIONS];
+  } else if (isPlatformBusy) {
+    kind = "server";
+    retryable = true;
+  } else if (statusCode === 429) {
+    kind = "rate_limit";
+    retryable = true;
+  } else if (statusCode === 413) {
+    kind = "context_too_large";
+    retryable = true;
+    contextActions = [...CONTEXT_TOO_LARGE_ACTIONS];
+  } 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(
+          isPlatformBusy ? `\u5E73\u53F0\u670D\u52A1\u7E41\u5FD9${busyUpstreamDetail ? `\uFF08\u4E0A\u6E38 ${busyUpstreamDetail}\uFF09` : ""}` : `\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528${status ? ` (HTTP ${status})` : ""}`
+        );
+        break;
+      case "context_overflow":
+        parts.push(`\u4E0A\u4E0B\u6587\u8D85\u51FA\u6A21\u578B\u7A97\u53E3${status ? ` (HTTP ${status})` : ""}`);
+        break;
+      case "context_too_large":
+        parts.push(`\u8BF7\u6C42\u5185\u5BB9\u8FC7\u5927${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 "context_overflow":
+        actionHint = "\u4E0A\u4E0B\u6587\u8D85\u51FA\u6A21\u578B\u7A97\u53E3\uFF1A\u53EF\u538B\u7F29\u5386\u53F2\u540E\u91CD\u8BD5\u3001\u5F00\u542F\u65B0\u5BF9\u8BDD\uFF0C\u6216\u5207\u6362\u5230\u66F4\u5927\u7A97\u53E3\u7684\u6A21\u578B\u3002";
+        break;
+      case "context_too_large":
+        actionHint = "\u5355\u6B21\u8BF7\u6C42\u5185\u5BB9\u8FC7\u5927\uFF1A\u8BF7\u51CF\u5C11\u53D1\u9001\u7684\u6D88\u606F\u3001\u6587\u4EF6\u6216\u5DE5\u5177\u7ED3\u679C\uFF0C\u6216\u5F00\u542F\u65B0\u5BF9\u8BDD\u3001\u5207\u6362\u6A21\u578B\u3002";
+        break;
+      case "auth":
+        actionHint = "\u8BF7\u68C0\u67E5\u8D26\u53F7\u767B\u5F55\u72B6\u6001\u6216 API \u5BC6\u94A5\u914D\u7F6E";
+        break;
+      case "server":
+        actionHint = isPlatformBusy ? "\u5E73\u53F0\u7B97\u529B\u6682\u65F6\u7D27\u5F20\uFF0C\u7A0D\u5019\u70B9\u51FB\u91CD\u8BD5\u901A\u5E38\u53EF\u6062\u590D" : "\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,
+      ...contextActions ? { actions: contextActions } : {}
+    };
+  }
+  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,
+    ...contextActions ? { actions: contextActions } : {}
+  };
+}
+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,
+    // 上下文超窗 / 内容过大时带上结构化动作（review 修复 2）：
+    // 没有这个字段，SendErrorCard 的 compact-and-retry / new-dialog /
+    // switch-model 三枚按钮永远不会出现，用户只剩一行文本提示。
+    // 其余 kind 不设 → 卡片只渲染重试。
+    ...parsed.actions ? { actions: parsed.actions } : {},
+    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 selectedRuntimeTarget = dialogConfig.runtimeBinding?.target;
+    const resolvedContext = resolveHandleSendMessageContext({
+      dialogConfig,
+      targetAgentKey: args.targetAgentKey,
+      runtimeOptions: {
+        ...args.runtimeOptions,
+        ...selectedRuntimeTarget && (selectedRuntimeTarget.kind === "server" || selectedRuntimeTarget.kind === "machine") ? { runtimeTarget: selectedRuntimeTarget } : {}
+      }
+    });
+    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 serverOwnedCandidate = await canRunServerOwnedWebForegroundTurn(
+      {
+        agentKey: agentKeyToUse,
+        agentConfig: agentConfigToUse,
+        userInput: effectiveRawUserInput,
+        dialogConfig,
+        runtimeOptions: effectiveRuntimeOptions,
+        contextBlocks: browseContextPrefix ? [browseContextPrefix] : void 0
+      },
+      { dispatch, getState }
+    );
+    if (serverOwnedCandidate.eligible && serverOwnedCandidate.agentConfig) {
+      const serverOwnedResult = await runServerOwnedWebForegroundTurn(
+        {
+          agentKey: agentKeyToUse,
+          agentConfig: serverOwnedCandidate.agentConfig,
+          userInput: effectiveRawUserInput,
+          dialogConfig,
+          runtimeOptions: effectiveRuntimeOptions,
+          contextBlocks: browseContextPrefix ? [browseContextPrefix] : void 0
+        },
+        { dispatch, getState }
+      );
+      if (serverOwnedResult.aborted || serverOwnedResult.detached) return;
+      logQuickChatPerfStage(args.quickChatPerfStartedAt, "handle-send-message-server-owned-finished", {
+        dialogKey: dialogConfig.dbKey,
+        agentKey: agentKeyToUse
+      });
+      return;
+    }
+    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
+};