nolo-cli 0.67.0 → 0.68.0-alpha.2

package/chunk-CLZYOOI3.js

@@ -1,4463 +0,0 @@
-import {
-  BUILTIN_SUMMARY_LLM_CONFIG
-} from "./chunk-EVBFYPDC.js";
-import {
-  buildDialogAttachmentPlan,
-  extractFileContentIds
-} from "./chunk-HQUORJTM.js";
-import {
-  isOAuthApiKeyRef
-} from "./chunk-YYLHWIW6.js";
-import {
-  getApproxPricePerImage
-} from "./chunk-AGGIDPCZ.js";
-import {
-  runLlm
-} from "./chunk-OHJWIXXW.js";
-import {
-  cleanupCliSessionForDialog
-} from "./chunk-76JAMDUT.js";
-import {
-  getActiveDialogAgentId,
-  getDialogAgentIds,
-  getPrimaryDialogAgentId
-} from "./chunk-5RGU3J7P.js";
-import {
-  abortActiveControllers,
-  addPageReferenceToRuntime,
-  applyClearDialogStateRuntime,
-  applyUpdateTokensFulfilled,
-  clearActiveControllers,
-  deleteDialogRuntime,
-  getActiveDialogKey,
-  getDialogRuntimeTokens,
-  resetDialogRuntimeSessionState,
-  selectCurrentDialogKey,
-  setActiveDialogKey,
-  setDialogConfigError
-} from "./chunk-6YTOJY35.js";
-import {
-  require_date_fns
-} from "./chunk-M76ECQRD.js";
-import {
-  require_react
-} from "./chunk-YDH3FDFQ.js";
-import {
-  DEFAULT_AUTO_EXECUTION_PROFILE,
-  DEFAULT_CONTEXT_WINDOW,
-  EMPTY_ASSISTANT_FALLBACK_MESSAGE,
-  LENGTH_TRUNCATED_FALLBACK_MESSAGE,
-  REPETITION_LOOP_FALLBACK_MESSAGE,
-  STAGNANT_TOOL_CALLS_FALLBACK_MESSAGE,
-  STREAM_TRUNCATED_FALLBACK_MESSAGE,
-  getModelContextWindow,
-  getModelInfo,
-  readCacheCreationInputTokens,
-  readCacheReadInputTokens,
-  resolveAutoExecutionProfile
-} from "./chunk-HQ3ZLBSI.js";
-import {
-  COMPACTION_SUMMARY_SYSTEM_PROMPT,
-  buildCompactionMetricsFromPlan,
-  buildCompactionUserContent,
-  formatCompactionMetricsLog,
-  formatFileOperationsFromMessages,
-  formatMessagesForSummaryWithTruncation,
-  normalizeAssistantContentBuffer,
-  normalizeTimingMs,
-  planCompression,
-  serializeMessageContent
-} from "./chunk-TDTSQVDX.js";
-import {
-  estimateTokenCount
-} from "./chunk-PSCNXBYA.js";
-import {
-  findModelConfig,
-  getModelConfig
-} from "./chunk-TQC77XVE.js";
-import {
-  toErrorMessage
-} from "./chunk-HNMXYYJR.js";
-import {
-  fetchMessages
-} from "./chunk-BYEJ7K2Z.js";
-import {
-  PLATFORM_HOSTED_DEEPSEEK_FLASH_MODEL,
-  PLATFORM_HOSTED_DEEPSEEK_PRO_MODEL,
-  PLATFORM_HOSTED_GLM_53_FLASH_BASETEN_PRICE,
-  PLATFORM_HOSTED_GLM_53_FLASH_MODEL,
-  getPlatformHostedDeepSeekV4Price,
-  isPlatformHostedClaudeModel,
-  isPlatformHostedDeepSeekV4Model,
-  isPlatformHostedImageModel,
-  isPlatformHostedOpenAIImageModel
-} from "./chunk-5YIL5WDC.js";
-import {
-  nolotusId
-} from "./chunk-OPNHMILE.js";
-import {
-  asRecordOrEmpty
-} from "./chunk-KX6YBIHG.js";
-import {
-  patch,
-  read,
-  remove,
-  selectById,
-  write
-} from "./chunk-4K6DB3GJ.js";
-import {
-  buildDialogAgentListIndexDeleteOps,
-  createDialogMessageKeyAndId,
-  createKey,
-  createTokenKey,
-  createTokenStatsKey,
-  dialogMessageKey,
-  isDialogRecordKey,
-  isPageKey,
-  isTableMetaKey
-} from "./chunk-NHRQCXIQ.js";
-import {
-  asOptionalFiniteNumber
-} from "./chunk-WWC7I6TA.js";
-import {
-  asTrimmedNonEmptyStringArray
-} from "./chunk-I42VC5KR.js";
-import {
-  asTrimmedLowercaseString
-} from "./chunk-QSJ3HFEF.js";
-import {
-  builtinAgentCatalogEntryById,
-  builtinRuntimeFallbackEntries,
-  isBuiltinPlatformAgentKey
-} from "./chunk-4MKPBCTN.js";
-import {
-  extractCustomId,
-  extractUserId,
-  parsePublicAgentId,
-  publicAgentKey
-} from "./chunk-BJIRLHJR.js";
-import {
-  asyncThunkCreator,
-  buildCreateSlice,
-  createAsyncThunk,
-  createEntityAdapter,
-  createSelector,
-  getRuntimeServerContext,
-  parseOwnerUserIdFromDbKey,
-  scheduleDeleteReplication
-} from "./chunk-3RAG2NAD.js";
-import {
-  createClientLogger,
-  isAbortError
-} from "./chunk-QOKAKDPE.js";
-import {
-  selectIdentityToken,
-  selectIdentityUser,
-  selectIdentityUserId
-} from "./chunk-SEJ5OS6F.js";
-import {
-  isTombstoneRecord,
-  shouldReplaceWithNextRecord
-} from "./chunk-GBRG75BQ.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
-import {
-  asOptionalTrimmedString
-} from "./chunk-G3SUCT4W.js";
-import {
-  __toESM
-} from "./chunk-4VNS5WPM.js";
-
-// packages/chat/dialog/actions/addReferenceKeysAction.ts
-var extractReferenceKeys = (content) => {
-  const keys = /* @__PURE__ */ new Set();
-  if (Array.isArray(content)) {
-    for (const part of content) {
-      if (part && typeof part === "object") {
-        if (part.pageKey) keys.add(part.pageKey);
-        if (part.dialogKey) keys.add(part.dialogKey);
-      }
-    }
-  } else if (content && typeof content === "object") {
-    if (content.pageKey) keys.add(content.pageKey);
-    if (content.dialogKey) keys.add(content.dialogKey);
-  }
-  return Array.from(keys);
-};
-var addReferenceKeysAction = createAsyncThunk(
-  "dialog/addReferenceKeys",
-  async (args, { getState, dispatch }) => {
-    const { content, dialogKey } = args;
-    const newKeys = extractReferenceKeys(content);
-    if (newKeys.length === 0) return;
-    const state = getState();
-    const dialogConfig = selectById(state, dialogKey);
-    if (!dialogConfig) return;
-    const existingKeys = new Set(dialogConfig.referenceKeys || []);
-    const keysToAdd = newKeys.filter((k) => !existingKeys.has(k));
-    if (keysToAdd.length === 0) return;
-    const updatedKeys = [...Array.from(existingKeys), ...keysToAdd];
-    await dispatch(
-      patch({
-        dbKey: dialogKey,
-        changes: {
-          referenceKeys: updatedKeys
-        }
-      })
-    );
-  }
-);
-
-// packages/chat/messages/toolPresentation.ts
-var SUMMARY_EMOJI_PREFIX = new RegExp("^(\\p{Emoji_Presentation}|\\p{Extended_Pictographic}|\\[[vx!]\\])\\s*", "u");
-
-// packages/chat/messages/assistantMessageFacts.ts
-var isAssistantToolStub = (msg) => msg?.role === "assistant" && (msg.content == null || typeof msg.content === "string" && msg.content.trim().length === 0 || Array.isArray(msg.content) && msg.content.length === 0) && Array.isArray(msg?.tool_calls) && msg.tool_calls.length > 0;
-
-// packages/chat/messages/messageDeleteCascade.ts
-function planDeleteMessageCascade(msg, entities) {
-  const msgId = msg?.id;
-  let extraRemoveId;
-  let extraRemoveDbKey;
-  if (msg?.role === "tool" && msg.parentMessageId) {
-    const parent = entities[msg.parentMessageId];
-    if (parent && parent.role === "assistant" && isAssistantToolStub(parent)) {
-      const hasOtherToolMsgs = Object.values(entities).some(
-        (m) => m && m.role === "tool" && m.parentMessageId === msg.parentMessageId && m.dbKey !== msg.dbKey
-      );
-      if (!hasOtherToolMsgs) {
-        extraRemoveId = parent.id;
-        extraRemoveDbKey = parent.dbKey;
-      }
-    }
-  }
-  return { id: msgId, extraRemoveId, extraRemoveDbKey };
-}
-
-// packages/chat/messages/messageEditContent.ts
-var buildEditedMessageContent = (originalContent, nextText) => {
-  const trimmedText = nextText.trim();
-  if (typeof originalContent === "string") {
-    return trimmedText;
-  }
-  if (Array.isArray(originalContent)) {
-    const nextParts = originalContent.filter(
-      (part) => part && typeof part === "object" && part.type !== "text"
-    );
-    if (trimmedText) {
-      nextParts.unshift({ type: "text", text: trimmedText });
-    }
-    return nextParts;
-  }
-  return trimmedText;
-};
-
-// packages/chat/messages/messageEditReplayPlan.ts
-function planEditUserMessageAndReplay(input) {
-  const { messages, messageId, originalContent, nextText } = input;
-  const targetIndex = messages.findIndex((message) => message.id === messageId);
-  if (targetIndex < 0) {
-    return {
-      ok: false,
-      error: "target_not_found",
-      message: "editUserMessageAndReplay: target message not found."
-    };
-  }
-  const targetMessage = messages[targetIndex];
-  if (!targetMessage || targetMessage.role !== "user") {
-    return {
-      ok: false,
-      error: "not_user_message",
-      message: "\u53EA\u80FD\u7F16\u8F91\u7528\u6237\u6D88\u606F\u3002"
-    };
-  }
-  if (messages.some((message) => message.isStreaming)) {
-    return {
-      ok: false,
-      error: "streaming_in_progress",
-      message: "\u8BF7\u7B49\u5F85\u5F53\u524D\u56DE\u590D\u5B8C\u6210\u540E\u518D\u7F16\u8F91\u5386\u53F2\u6D88\u606F\u3002"
-    };
-  }
-  const nextContent = buildEditedMessageContent(
-    originalContent ?? targetMessage.content,
-    nextText
-  );
-  const trailingMessages = messages.slice(targetIndex + 1);
-  return {
-    ok: true,
-    targetMessage,
-    nextContent,
-    trailingMessages
-  };
-}
-
-// packages/chat/messages/messageFinalizeOnError.ts
-function messageHasDisplayContent(content) {
-  if (typeof content === "string") {
-    return content.trim().length > 0;
-  }
-  return Array.isArray(content) && content.length > 0;
-}
-function resolveFinalizeTransientOnError(existing, error) {
-  if (!existing) return { kind: "noop" };
-  if (!messageHasDisplayContent(existing.content)) {
-    return { kind: "remove" };
-  }
-  return {
-    kind: "markError",
-    changes: {
-      isStreaming: false,
-      metadata: {
-        ...existing.metadata ?? {},
-        error: true,
-        ...error ? { message: error } : {}
-      }
-    }
-  };
-}
-
-// packages/chat/messages/messageInitMsgsPolicy.ts
-function resolveInitMsgsFulfilledWriteMode(input) {
-  if (input.isNew || input.hasLocalStreaming) return "upsert";
-  return "replace";
-}
-function resolveInitMsgsHasMoreOlder(input) {
-  const { limit, fetchedCount } = input;
-  if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) {
-    return fetchedCount >= limit;
-  }
-  return false;
-}
-
-// packages/chat/messages/messageInitMsgsSummaryResume.ts
-function findDialogConfigByDialogId(entities, dialogId) {
-  return Object.values(entities ?? {}).find(
-    (entity) => {
-      if (!entity || typeof entity !== "object") return false;
-      const value = entity;
-      return value.type === "dialog" /* DIALOG */ && value.id === dialogId;
-    }
-  );
-}
-function resolveInitMsgsSummaryResume(input) {
-  const dialogConfig = findDialogConfigByDialogId(input.entities, input.dialogId);
-  if (dialogConfig && dialogConfig.summaryPending && dialogConfig.dbKey) {
-    return { resume: true, dialogKey: dialogConfig.dbKey };
-  }
-  return { resume: false };
-}
-
-// packages/chat/messages/messageValidation.ts
-var isValidMessage = (msg) => !!msg && typeof msg === "object" && typeof msg.id === "string";
-
-// packages/chat/messages/fetchConvMsgs.ts
-var FETCH_TIMEOUT = 5e3;
-var fetchConvMsgs = async (server, token, {
-  dialogId,
-  dialogKey,
-  limit,
-  beforeKey
-}, options = {}) => {
-  const { signal: externalSignal } = options;
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
-  const onExternalAbort = () => controller.abort();
-  externalSignal?.addEventListener("abort", onExternalAbort);
-  try {
-    const response = await fetch(`${server}/rpc/getConvMsgs`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        dialogId,
-        ...dialogKey && { dialogKey },
-        limit,
-        ...beforeKey && { beforeKey }
-      }),
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    externalSignal?.removeEventListener("abort", onExternalAbort);
-    if (!response.ok) {
-      console.error(`fetchConvMsgs: Failed ${response.status} from ${server}`);
-      return [];
-    }
-    const data = await response.json();
-    return Array.isArray(data) ? data : [];
-  } catch (error) {
-    clearTimeout(timeoutId);
-    externalSignal?.removeEventListener("abort", onExternalAbort);
-    if (externalSignal?.aborted) {
-      throw error;
-    }
-    console.error(`fetchConvMsgs: Error fetching from ${server}:`, error);
-    return [];
-  }
-};
-
-// packages/app/utils/async.ts
-function swallowNonAbortError(promise, fallback, signal) {
-  return promise.catch((err) => {
-    if (isAbortError(err) || signal?.aborted) {
-      throw err;
-    }
-    console.error("Non-abort error in async op:", err);
-    return fallback;
-  });
-}
-
-// packages/chat/messages/fetchAndCacheMessages.ts
-var fetchAndCacheMessagesLocalFirst = async ({
-  db,
-  dialogId,
-  dialogKey,
-  // Default: full dialog history (no 50-message window that blinds multi-turn agents).
-  limit,
-  beforeKey,
-  token,
-  remoteServers = [],
-  signal
-}) => {
-  const startedAt = typeof performance !== "undefined" ? performance.now() : Date.now();
-  const localPromise = fetchMessages(db, dialogId, {
-    limit,
-    beforeKey,
-    throwOnError: false,
-    includeDeleted: true
-  }).catch(() => []);
-  const remotePromise = (async () => {
-    if (!token || remoteServers.length === 0) return [];
-    const results = await Promise.all(
-      remoteServers.map(
-        (server) => swallowNonAbortError(
-          fetchConvMsgs(
-            server,
-            token,
-            { dialogId, dialogKey, limit, beforeKey },
-            { signal }
-          ),
-          [],
-          void 0
-        )
-      )
-    );
-    return results.flat();
-  })();
-  let localSettledAt = null;
-  const localTimingPromise = localPromise.then((value) => {
-    localSettledAt = typeof performance !== "undefined" ? performance.now() : Date.now();
-    return value;
-  });
-  const localMsgs = await localTimingPromise;
-  const localMs = localSettledAt !== null ? Math.round(localSettledAt - startedAt) : null;
-  const earlyReturned = localMsgs.length > 0;
-  const remotePromiseWithMerge = (async () => {
-    let remoteSettledAt = null;
-    const remoteMsgs = await remotePromise.then((value) => {
-      remoteSettledAt = typeof performance !== "undefined" ? performance.now() : Date.now();
-      return value;
-    });
-    const freshLocalMsgs = await fetchMessages(db, dialogId, {
-      limit,
-      beforeKey,
-      throwOnError: false,
-      includeDeleted: true
-    }).catch(() => []);
-    const uniqueMap = /* @__PURE__ */ new Map();
-    const changedMessagesToCache = /* @__PURE__ */ new Map();
-    const put = (m, trackChange = false) => {
-      if (!m || !m.id) return;
-      const existing = uniqueMap.get(m.id);
-      if (existing && !shouldReplaceWithNextRecord(m, existing)) return;
-      uniqueMap.set(m.id, m);
-      if (trackChange) changedMessagesToCache.set(m.id, m);
-    };
-    localMsgs.forEach((m) => put(m));
-    freshLocalMsgs.forEach((m) => put(m));
-    remoteMsgs.forEach((m) => put(m, true));
-    if (changedMessagesToCache.size > 0) {
-      try {
-        const ops = Array.from(changedMessagesToCache.values()).map((msg) => {
-          let key = msg.dbKey || msg.dbKey;
-          if (!key) {
-            key = dialogMessageKey(dialogId, msg.id);
-          }
-          return {
-            type: "put",
-            key,
-            value: {
-              ...msg,
-              dbKey: key,
-              type: "msg" /* MSG */
-            }
-          };
-        });
-        await db.batch(ops);
-      } catch {
-      }
-    }
-    console.info("[fetchAndCacheMessages-perf]", {
-      dialogId,
-      localMs,
-      remoteMs: remoteSettledAt !== null ? Math.round(remoteSettledAt - startedAt) : null,
-      totalMs: Math.round(
-        (typeof performance !== "undefined" ? performance.now() : Date.now()) - startedAt
-      ),
-      localCount: localMsgs.length,
-      remoteCount: remoteMsgs.length,
-      remoteServerCount: remoteServers.length,
-      hasToken: !!token,
-      earlyReturned
-    });
-    return Array.from(uniqueMap.values()).filter((message) => !isTombstoneRecord(message)).sort((a, b) => {
-      const aCreated = a && typeof a === "object" && "createdAt" in a ? a.createdAt : void 0;
-      const bCreated = b && typeof b === "object" && "createdAt" in b ? b.createdAt : void 0;
-      const tA = new Date(aCreated || 0).getTime();
-      const tB = new Date(bCreated || 0).getTime();
-      return tB - tA;
-    });
-  })();
-  if (!earlyReturned) {
-    const mergedMessages = await remotePromiseWithMerge;
-    return {
-      localMessages: mergedMessages,
-      remotePromise: Promise.resolve(mergedMessages),
-      earlyReturned: false
-    };
-  }
-  return {
-    localMessages: localMsgs,
-    remotePromise: remotePromiseWithMerge,
-    earlyReturned: true
-  };
-};
-var fetchAndCacheMessages = async (options) => {
-  const { remotePromise } = await fetchAndCacheMessagesLocalFirst(options);
-  return remotePromise;
-};
-
-// packages/chat/messages/parseJsonRecord.ts
-function asOptionalJsonRecord(value) {
-  if (typeof value === "string") {
-    if (!value.trim()) return void 0;
-    try {
-      const parsed = JSON.parse(value);
-      return isRecord(parsed) ? parsed : void 0;
-    } catch {
-      return void 0;
-    }
-  }
-  return isRecord(value) ? value : void 0;
-}
-
-// packages/chat/dialog/actions/extractReferenceKeys.ts
-var REFERENCE_ARG_FIELDS = [
-  "pageKey",
-  "dialogKey",
-  "dbKey",
-  "docKey",
-  "key",
-  "id",
-  "rowDbKey",
-  "tableKey",
-  "table"
-];
-var isLoadableReferenceKey = (key) => isPageKey(key) || isDialogRecordKey(key) || isTableMetaKey(key);
-var extractKeysFromArgs = (args, out) => {
-  if (!args) return;
-  for (const field of REFERENCE_ARG_FIELDS) {
-    const value = args[field];
-    const key = asTrimmedString(value);
-    if (key && isLoadableReferenceKey(key)) {
-      out.add(key);
-    }
-  }
-};
-var extractKeysFromToolCalls = (msg, out) => {
-  const toolCalls = msg.tool_calls;
-  if (!Array.isArray(toolCalls)) return;
-  for (const call of toolCalls) {
-    const fn = call.function;
-    const argumentsText = asTrimmedString(fn.arguments);
-    if (!argumentsText) continue;
-    const parsed = asOptionalJsonRecord(argumentsText);
-    if (parsed) extractKeysFromArgs(parsed, out);
-  }
-};
-var extractKeysFromToolPayload = (toolPayload, out) => {
-  if (!toolPayload) return;
-  if (isRecord(toolPayload.input)) {
-    extractKeysFromArgs(
-      toolPayload.input,
-      out
-    );
-    return;
-  }
-  const rawToolCall = toolPayload.rawToolCall;
-  if (isRecord(rawToolCall)) {
-    const fn = rawToolCall.function;
-    if (isRecord(fn)) {
-      const argumentsText = asTrimmedString(fn.arguments);
-      if (argumentsText) {
-        const parsed = asOptionalJsonRecord(argumentsText);
-        if (parsed) extractKeysFromArgs(parsed, out);
-      }
-    }
-  }
-};
-var extractKeysFromContent = (msg, out) => {
-  const content = msg.content;
-  if (!content) return;
-  const parts = Array.isArray(content) ? content : [content];
-  for (const part of parts) {
-    if (!isRecord(part)) continue;
-    const pageKey = asTrimmedString(part.pageKey);
-    if (pageKey) out.add(pageKey);
-    const dialogKey = asTrimmedString(part.dialogKey);
-    if (dialogKey) out.add(dialogKey);
-  }
-};
-var extractReferenceKeysFromMessage = (msg) => {
-  const keys = /* @__PURE__ */ new Set();
-  extractKeysFromContent(msg, keys);
-  extractKeysFromToolCalls(msg, keys);
-  extractKeysFromToolPayload(msg.toolPayload, keys);
-  return Array.from(keys);
-};
-
-// packages/chat/dialog/actions/updateDialogSummaryAction.ts
-var getMessagesForDialogFromState = (state, dialogId) => {
-  const msgsState = state.message.dialogStateById[dialogId]?.msgs;
-  if (!msgsState || !msgsState.ids) return [];
-  return msgsState.ids.flatMap((id) => {
-    const msg = msgsState.entities[id];
-    return msg ? [msg] : [];
-  });
-};
-var identityCanonicalName = (name) => name;
-var summarizingDialogs = /* @__PURE__ */ new Set();
-var updateDialogSummaryAction = async (args, thunkApi) => {
-  const { dialogKey, preFetchedMessages, force = false } = args;
-  if (summarizingDialogs.has(dialogKey)) return;
-  summarizingDialogs.add(dialogKey);
-  const { dispatch, getState } = thunkApi;
-  try {
-    const state = getState();
-    const dialogId = extractCustomId(dialogKey);
-    const dialogConfig = selectById(state, dialogKey);
-    if (!dialogConfig) return;
-    let contextWindow = DEFAULT_CONTEXT_WINDOW;
-    if (dialogConfig.cybots && dialogConfig.cybots.length > 0) {
-      const agentId = dialogConfig.cybots[0];
-      const agent = selectById(state, agentId);
-      if (agent?.model) {
-        contextWindow = getModelContextWindow(agent.model);
-      }
-    }
-    const allMsgs = preFetchedMessages || getMessagesForDialogFromState(state, dialogId);
-    const plan = planCompression({
-      allMsgs,
-      summarizedBeforeId: dialogConfig.summarizedBeforeId,
-      summary: dialogConfig.summary || "",
-      contextWindow,
-      force,
-      reason: args.reason,
-      // 防死亡螺旋：用 summary 长度作为上次压缩后的基线。
-      lastCompactedTokenCount: dialogConfig.summary ? estimateTokenCount(dialogConfig.summary) : void 0
-    });
-    if (!plan.shouldCompress) return;
-    const { msgsToCompress, newSummarizedBeforeId } = plan;
-    const extractedKeys = new Set(dialogConfig.referenceKeys || []);
-    for (const msg of msgsToCompress) {
-      for (const key of extractReferenceKeysFromMessage(msg)) {
-        extractedKeys.add(key);
-      }
-    }
-    const previousSummary = dialogConfig.summary || "";
-    const messagesText = formatMessagesForSummaryWithTruncation(msgsToCompress);
-    const fileOpsText = formatFileOperationsFromMessages(
-      msgsToCompress,
-      identityCanonicalName
-    );
-    const promptContent = buildCompactionUserContent({
-      previousSummary,
-      messagesText,
-      fileOpsText
-    });
-    try {
-      const newSummary = await dispatch(
-        runLlm({
-          llmConfig: {
-            ...BUILTIN_SUMMARY_LLM_CONFIG,
-            prompt: COMPACTION_SUMMARY_SYSTEM_PROMPT
-          },
-          content: promptContent,
-          billingDialogKey: dialogKey
-        })
-      ).unwrap();
-      if (newSummary && typeof newSummary === "string" && newSummary.trim()) {
-        const currentCount = dialogConfig.compressionCount || 0;
-        await dispatch(
-          patch({
-            dbKey: dialogKey,
-            changes: {
-              summary: newSummary.trim(),
-              summarizedBeforeId: newSummarizedBeforeId,
-              referenceKeys: Array.from(extractedKeys),
-              compressionCount: currentCount + 1,
-              summaryPending: false
-              // Explicitly clear pending flag
-            }
-          })
-        ).unwrap();
-        const metrics = buildCompactionMetricsFromPlan({
-          reason: args.reason || "context_budget",
-          previousSummary: dialogConfig.summary || "",
-          plan,
-          newSummary: newSummary.trim()
-          // web 端 runLlm 只返回摘要字符串，不含 usage。
-          // summaryUsage 需要 runLlm 改造才能获取，当前留空。
-        });
-        console.log(formatCompactionMetricsLog(metrics));
-      }
-    } catch (err) {
-      console.error("[ContextCompression] Failed:", err);
-    }
-  } finally {
-    summarizingDialogs.delete(dialogKey);
-  }
-};
-
-// packages/chat/messages/normalizeHistoricalReasoning.ts
-var HISTORICAL_REASONING_FALLBACK_MESSAGES = /* @__PURE__ */ new Set([
-  EMPTY_ASSISTANT_FALLBACK_MESSAGE,
-  LENGTH_TRUNCATED_FALLBACK_MESSAGE,
-  STREAM_TRUNCATED_FALLBACK_MESSAGE,
-  REPETITION_LOOP_FALLBACK_MESSAGE,
-  STAGNANT_TOOL_CALLS_FALLBACK_MESSAGE
-]);
-function normalizeHistoricalReasoningMessage(message) {
-  if (!message || typeof message !== "object") {
-    return message;
-  }
-  if (message.role !== "assistant") {
-    return message;
-  }
-  if (typeof message.thinkContent === "string" && message.thinkContent.trim().length > 0) {
-    return message;
-  }
-  const reasoning = message.reasoning_content;
-  if (typeof reasoning !== "string" || reasoning.trim().length === 0) {
-    return message;
-  }
-  const content = message.content;
-  if (typeof content !== "string" || !HISTORICAL_REASONING_FALLBACK_MESSAGES.has(content.trim())) {
-    return message;
-  }
-  return {
-    ...message,
-    thinkContent: reasoning
-  };
-}
-
-// packages/chat/messages/messageContract.ts
-function separateThinkContent(contentBuffer) {
-  let thinkContent = "";
-  let normalContent = "";
-  const combinedText = contentBuffer.flatMap(
-    (c) => c.type === "text" && "text" in c && c.text ? [c.text] : []
-  ).join("");
-  const thinkMatches = combinedText.match(/<think\b[^>]*>(.*?)<\/think>/gis);
-  if (thinkMatches) {
-    thinkContent = thinkMatches.map((m) => m.replace(/<think\b[^>]*>|<\/think>/gi, "")).join("\n\n");
-    normalContent = combinedText.replace(/<think\b[^>]*>.*?<\/think>/gis, "").trim();
-  } else {
-    normalContent = combinedText;
-  }
-  return { thinkContent, normalContent };
-}
-function countImageParts(content) {
-  if (!Array.isArray(content)) return 0;
-  return content.filter((part) => part?.type === "image_url").length;
-}
-function finalizeAssistantMessageContent(normalizedContentBuffer, reasoningBuffer = "") {
-  const { thinkContent: tagThink, normalContent } = separateThinkContent(normalizedContentBuffer);
-  const thinkContent = `${tagThink}${reasoningBuffer}`.trim();
-  const hasNonTextParts = normalizedContentBuffer.some(
-    (part) => part && part.type && part.type !== "text"
-  );
-  return {
-    thinkContent,
-    textContent: normalContent || "",
-    visibleContent: hasNonTextParts ? normalizedContentBuffer : normalContent || "",
-    hasNonTextParts,
-    imagePartCount: countImageParts(normalizedContentBuffer)
-  };
-}
-function appendSaveFailureToContent(content) {
-  const failureText = "[Failed to save message]";
-  if (Array.isArray(content)) {
-    return [...content, { type: "text", text: failureText }];
-  }
-  if (typeof content === "string" && content.length > 0) {
-    return `${content}
-${failureText}`;
-  }
-  return failureText;
-}
-
-// packages/create/space/contentKeyUtils.ts
-var isAppContentKey = (contentKey) => typeof contentKey === "string" && contentKey.startsWith("app-");
-var normalizeAppRouteId = (contentKey) => isAppContentKey(contentKey) ? contentKey : `app-${contentKey}`;
-
-// packages/ai/tools/uiAskChoiceTool.ts
-var uiAskChoiceFunctionSchema = {
-  name: "ask_user",
-  description: "\u8BA9\u7528\u6237\u5728 2\uFF5E5 \u4E2A\u4E92\u65A5\u9009\u9879\u4E4B\u95F4\u505A\u9009\u62E9\u7684\u901A\u7528\u201C\u51FA\u9009\u9879\u201D\u5DE5\u5177\uFF08\u9700\u6C42\u6A21\u7CCA\u3001\u5206\u652F\u51B3\u7B56\u3001\u95EE\u5377\u7B49\uFF09\u3002\u8C03\u7528\u524D\u987B\u5148\u5728\u666E\u901A\u56DE\u590D\u6587\u672C\u91CC\u89E3\u91CA\u80CC\u666F\u4E0E\u6743\u8861\uFF08\u5148\u89E3\u91CA\uFF0C\u518D\u8C03\u7528\uFF09\u3002\u591A\u95EE\u9898\u4F20 questions\uFF0C\u5355\u95EE\u9898\u4F20 question+choices\u3002",
-  parameters: {
-    type: "object",
-    properties: {
-      question: {
-        type: "string",
-        description: "\u5C55\u793A\u7ED9\u7528\u6237\u7684\u95EE\u9898\u6587\u6848\uFF08\u5355\u95EE\u9898\u6A21\u5F0F\uFF09\u3002\u4E0E questions \u4E8C\u9009\u4E00\u3002"
-      },
-      choices: {
-        type: "array",
-        description: "\u5907\u9009\u9879\u5217\u8868\uFF0C\u6E32\u67D3\u4E3A\u6309\u94AE\u4F9B\u7528\u6237\u70B9\u51FB\u3002",
-        items: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string",
-              description: "\u9009\u9879\u6807\u8BC6\u3002"
-            },
-            label: {
-              type: "string",
-              description: "\u6309\u94AE\u6587\u5B57\uFF0C\u5982\u201C\u751F\u6210\u672C\u5468\u5468\u62A5\u201D\u3002"
-            },
-            detail: {
-              type: "string",
-              description: "\u7B80\u77ED\u8865\u5145\uFF08\u5EFA\u8BAE\u4E00\u53E5\u8BDD\uFF09\uFF0C\u957F\u89E3\u91CA\u5199\u8FDB\u8C03\u7528\u524D\u7684\u56DE\u590D\u6587\u672C\u3002"
-            },
-            recommended: {
-              type: "boolean",
-              description: "\u6807\u8BB0\u4E3A\u63A8\u8350\u9879\uFF08\u653E\u9996\u4F4D\u5E76\u7F6E true\uFF0C\u65E0\u63A8\u8350\u5219\u7701\u7565\uFF09\u3002"
-            },
-            userMessage: {
-              type: "string",
-              description: "\u70B9\u51FB\u540E\u4F5C\u4E3A\u4E0B\u4E00\u6761 user \u6D88\u606F\u53D1\u9001\u7684\u6587\u6848\uFF08\u7559\u7A7A\u9ED8\u8BA4\u7528 label\uFF09\u3002"
-            }
-          },
-          required: ["id", "label"]
-        }
-      },
-      questions: {
-        type: "array",
-        description: "\u591A\u95EE\u9898\u6A21\u5F0F\uFF08\u591A tab \u6E32\u67D3\uFF0C\u4E0E question+choices \u4E8C\u9009\u4E00\uFF09\u3002",
-        items: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string",
-              description: "\u95EE\u9898\u6807\u8BC6\u3002"
-            },
-            header: {
-              type: "string",
-              description: "\u591A\u95EE\u9898 tab \u680F\u663E\u793A\u7684\u77ED\u6807\u7B7E\uFF08\u226412 \u5B57\u7B26\uFF0C\u5982\u201C\u683C\u5F0F/\u8BED\u8A00/\u8303\u56F4\u201D\uFF09\uFF0C\u7F3A\u7701\u7528 Qn\u3002"
-            },
-            question: {
-              type: "string",
-              description: "\u95EE\u9898\u6587\u6848\u3002"
-            },
-            choices: {
-              type: "array",
-              description: "\u8BE5\u95EE\u9898\u7684\u5907\u9009\u9879\u3002",
-              items: {
-                type: "object",
-                properties: {
-                  id: { type: "string" },
-                  label: { type: "string" },
-                  detail: {
-                    type: "string",
-                    description: "\u7B80\u77ED\u8865\u5145\uFF08\u5EFA\u8BAE\u4E00\u53E5\u8BDD\uFF09\uFF0C\u957F\u89E3\u91CA\u5199\u8FDB\u8C03\u7528\u524D\u7684\u56DE\u590D\u6587\u672C\u3002"
-                  },
-                  recommended: {
-                    type: "boolean",
-                    description: "\u63A8\u8350\u9879\u6807\u8BB0\uFF08\u7F6E true \u6807\u63A8\u8350\uFF0C\u65E0\u5219\u7701\u7565\uFF09\u3002"
-                  },
-                  userMessage: { type: "string" }
-                },
-                required: ["id", "label"]
-              }
-            },
-            multiSelect: {
-              type: "boolean",
-              description: "\u5141\u8BB8\u591A\u9009\uFF0C\u9ED8\u8BA4 false\u3002"
-            },
-            allowOther: {
-              type: "boolean",
-              description: "\u663E\u793A\u201C\u5176\u4ED6\u201D\u81EA\u7531\u8F93\u5165\u884C\uFF0C\u9ED8\u8BA4 true\u3002"
-            },
-            required: {
-              type: "boolean",
-              description: "\u662F\u5426\u5FC5\u987B\u56DE\u7B54\u624D\u80FD\u63D0\u4EA4\uFF0C\u9ED8\u8BA4 true\u3002"
-            }
-          },
-          required: ["id", "question", "choices"]
-        }
-      },
-      blocking: {
-        type: "boolean",
-        description: "\u662F\u5426\u7B49\u5F85\u7528\u6237\u9009\u62E9\u540E\u518D\u7EE7\u7EED\u6D41\u7A0B\uFF0C\u9ED8\u8BA4 true\u3002"
-      }
-    },
-    required: []
-  }
-};
-async function uiAskChoiceFunc(args, _thunkApi) {
-  const blocking = args?.blocking !== false;
-  if (Array.isArray(args?.questions) && args.questions.length > 0) {
-    const firstQ = args.questions[0];
-    return {
-      rawData: {
-        type: "ask_user",
-        question: firstQ?.question ?? "",
-        choices: firstQ?.choices ?? [],
-        blocking,
-        questions: args.questions
-      },
-      displayData: args.questions.map((q) => q.question).join(" / ")
-    };
-  }
-  const question = String(args?.question ?? "").trim();
-  const choices = Array.isArray(args?.choices) ? args.choices : [];
-  if (!question || choices.length === 0) {
-    throw new Error("ask_user \u9700\u8981 question+choices \u6216 questions\u3002");
-  }
-  return {
-    rawData: {
-      type: "ask_user",
-      question,
-      choices,
-      blocking
-    },
-    displayData: question
-  };
-}
-function parseUiAskChoiceContent(rawContent) {
-  const parsed = typeof rawContent === "string" ? (() => {
-    try {
-      return JSON.parse(rawContent);
-    } catch {
-      return null;
-    }
-  })() : rawContent;
-  if (!parsed || typeof parsed !== "object") return null;
-  if (parsed.type !== "ask_user") return null;
-  return parsed;
-}
-
-// packages/ai/policy/personalizationDialog.ts
-var PERSONALIZATION_DIALOG_CATEGORY = "user-overlay-profile";
-var PERSONALIZATION_DIALOG_EXTRA_TOOLS = [
-  "ask_user",
-  "updateUserPreferenceProfile"
-];
-var buildPersonalizationRuntimeOptions = (runtimeOptions) => ({
-  ...runtimeOptions,
-  extraTools: Array.from(
-    /* @__PURE__ */ new Set([
-      ...runtimeOptions?.extraTools ?? [],
-      ...PERSONALIZATION_DIALOG_EXTRA_TOOLS
-    ])
-  )
-});
-var buildPersonalizationDialogPolicyContext = () => [
-  "\u5F53\u524D\u5BF9\u8BDD\u662F\u201C\u7528\u6237\u4E2A\u6027\u5316\u8BBE\u7F6E\u201D\u6A21\u5F0F\uFF0C\u4E0D\u662F\u666E\u901A\u95F2\u804A\u3002",
-  "\u4F60\u7684\u76EE\u6807\u662F\u7528\u7B80\u77ED\u5BF9\u8BDD\u5E2E\u52A9\u7528\u6237\u786E\u8BA4 tone\u3001knowledge_capture\u3001space_context \u8FD9\u4E09\u9879\u504F\u597D\u3002",
-  "\u5982\u679C\u7528\u6237\u5148\u4ECB\u7ECD\u81EA\u5DF1\u3001\u5DE5\u4F5C\u65B9\u5F0F\u6216\u957F\u671F\u6C9F\u901A\u504F\u597D\uFF0C\u8BF7\u628A\u8FD9\u4E9B\u53EF\u590D\u7528\u4FE1\u606F\u6574\u7406\u6210\u7B80\u6D01\u7684 globalPrompt \u8349\u6848\uFF0C\u5E76\u5728\u7528\u6237\u786E\u8BA4\u540E\u901A\u8FC7 updateUserPreferenceProfile \u4FDD\u5B58\u3002",
-  "\u4F18\u5148\u4E00\u6B21\u53EA\u95EE\u4E00\u4E2A\u95EE\u9898\uFF1B\u5F53\u5B58\u5728\u6E05\u6670\u4E92\u65A5\u9009\u9879\u65F6\uFF0C\u4F18\u5148\u8C03\u7528 ask_user\u3002",
-  "\u6536\u96C6\u5230\u8DB3\u591F\u4FE1\u606F\u540E\uFF0C\u8C03\u7528 updateUserPreferenceProfile \u4FDD\u5B58\u7ED3\u679C\uFF0C\u7136\u540E\u7528\u81EA\u7136\u8BED\u8A00\u603B\u7ED3\u5DF2\u4FDD\u5B58\u7684\u8BBE\u7F6E\u3002",
-  "\u4FDD\u5B58\u5B8C\u6210\u540E\uFF0C\u8981\u63D0\u9192\u7528\u6237\uFF1A\u4EE5\u540E\u4E5F\u53EF\u4EE5\u5728\u8BBE\u7F6E\u91CC\u4FEE\u6539 globalPrompt \u548C\u8FD9\u4E9B\u504F\u597D\uFF0C\u6216\u8005\u518D\u6B21\u6253\u5F00\u8FD9\u4E2A\u5165\u53E3\u7EE7\u7EED\u8C03\u6574\u3002",
-  "\u4E2A\u6027\u5316\u8BBE\u7F6E\u5B8C\u6210\u540E\uFF0C\u53EF\u987A\u624B\u5F15\u5BFC\u7528\u6237\u5C1D\u8BD5 1 \u5230 2 \u4E2A\u76F8\u5173\u529F\u80FD\uFF0C\u4F8B\u5982\u9996\u9875\u5FEB\u6377\u5BF9\u8BDD\u3001\u521B\u5EFA\u7B14\u8BB0\u3001\u521B\u5EFA AI\uFF0C\u4F46\u4E0D\u8981\u4E00\u6B21\u63A8\u8350\u592A\u591A\u3002",
-  "\u9664\u975E\u7528\u6237\u660E\u786E\u8981\u6C42\uFF0C\u5426\u5219\u4E0D\u8981\u521B\u5EFA\u6587\u6863\uFF0C\u4E0D\u8981\u521B\u5EFA\u6216\u4FEE\u6539\u4EFB\u4F55 agent\u3002"
-].join("\n");
-
-// packages/agent-runtime/builtinPlatformAgentRoute.ts
-function resolveBuiltinAgentRuntimeFields(agentKey) {
-  if (!isBuiltinPlatformAgentKey(agentKey)) return null;
-  const entry = builtinAgentCatalogEntryById(parsePublicAgentId(agentKey));
-  if (!entry) return null;
-  return { provider: entry.provider, model: entry.model };
-}
-
-// packages/agent-runtime/builtinPlatformAgentConfigs.ts
-function buildConfig(e) {
-  const key = publicAgentKey(e.id);
-  const rawRecord = {
-    dbKey: key,
-    isPublic: true,
-    provider: e.provider,
-    model: e.model,
-    apiSource: e.apiSource ?? "platform",
-    useServerProxy: e.useServerProxy ?? true
-  };
-  if (e.hasImageOutput) rawRecord.hasImageOutput = true;
-  if (e.imageModel) rawRecord.imageModel = e.imageModel;
-  if (e.imageWorkflow) rawRecord.imageWorkflow = e.imageWorkflow;
-  if (e.imageConfig) rawRecord.imageConfig = e.imageConfig;
-  return {
-    key,
-    name: e.name,
-    provider: e.provider,
-    model: e.model,
-    apiSource: e.apiSource ?? "platform",
-    useServerProxy: e.useServerProxy ?? true,
-    rawRecord
-  };
-}
-var BUILTIN_PLATFORM_AGENT_CONFIGS = Object.fromEntries(
-  builtinRuntimeFallbackEntries().map((e) => [publicAgentKey(e.id), buildConfig(e)])
-);
-function resolveBuiltinPlatformAgentConfig(agentRef) {
-  return BUILTIN_PLATFORM_AGENT_CONFIGS[agentRef] ?? null;
-}
-function resolveBuiltinPlatformAgentRecord(agentRef) {
-  const config = resolveBuiltinPlatformAgentConfig(agentRef);
-  if (!config) return null;
-  return {
-    ...config.rawRecord,
-    dbKey: agentRef,
-    ...config.name ? { name: config.name } : {}
-  };
-}
-function applyBuiltinAgentRuntimeOverride(agentKey, record) {
-  const fields = resolveBuiltinAgentRuntimeFields(agentKey);
-  if (!fields) return record;
-  const current = record;
-  const rawNeedsOverride = current.rawRecord != null && (current.rawRecord.provider !== fields.provider || current.rawRecord.model !== fields.model);
-  if (current.provider === fields.provider && current.model === fields.model && !rawNeedsOverride) {
-    return record;
-  }
-  return {
-    ...record,
-    provider: fields.provider,
-    model: fields.model,
-    ...current.rawRecord ? {
-      rawRecord: {
-        ...current.rawRecord,
-        provider: fields.provider,
-        model: fields.model
-      }
-    } : {}
-  };
-}
-
-// packages/chat/dialog/dialogAgentPolicy.ts
-var resolveDialogAgentMode = (dialog) => {
-  if (dialog?.agentMode === "auto") return "auto";
-  if (dialog?.agentMode === "fixed") return "fixed";
-  return getActiveDialogAgentId(dialog) ? "fixed" : "auto";
-};
-var isAutoDialog = (dialog) => resolveDialogAgentMode(dialog) === "auto";
-var resolveDialogAutoTier = (dialog) => {
-  const tier = asOptionalTrimmedString(dialog?.autoRoute?.stickyTier);
-  if (tier === "image") return "flash";
-  return tier === "flash" || tier === "balanced" || tier === "quality" ? tier : void 0;
-};
-var resolveDialogRuntimeAgentKey = (dialog, explicitAgentKey) => {
-  const explicit = asOptionalTrimmedString(explicitAgentKey);
-  if (explicit) return explicit;
-  if (resolveDialogAgentMode(dialog) === "fixed") {
-    const fixed = getActiveDialogAgentId(dialog);
-    if (fixed) return fixed;
-  }
-  return resolveAutoExecutionProfile(
-    resolveDialogAutoTier(dialog) ?? DEFAULT_AUTO_EXECUTION_PROFILE.tier
-  ).legacyAgentKey;
-};
-var resolveDialogRuntimeAgentConfig = (dialog, explicitAgentKey) => {
-  if (!isAutoDialog(dialog)) return null;
-  const key = resolveDialogRuntimeAgentKey(dialog, explicitAgentKey);
-  return resolveBuiltinPlatformAgentRecord(key) ?? null;
-};
-
-// packages/chat/dialog/actions/handleSendMessageResolver.ts
-function resolveHandleSendMessageContext(input) {
-  const { dialogConfig, targetAgentKey, runtimeOptions } = input;
-  return {
-    agentKeyToUse: resolveDialogRuntimeAgentKey(dialogConfig, targetAgentKey),
-    agentConfigToUse: resolveDialogRuntimeAgentConfig(dialogConfig, targetAgentKey) ?? void 0,
-    effectiveRuntimeOptions: dialogConfig.category === PERSONALIZATION_DIALOG_CATEGORY ? buildPersonalizationRuntimeOptions(runtimeOptions ?? {}) : runtimeOptions
-  };
-}
-
-// packages/chat/messages/resolveMessageOwner.ts
-var resolveMessageOwner = (input) => {
-  const dialogConfigUserId = asOptionalTrimmedString(input.dialogConfigUserId) ?? null;
-  const currentAccountUserId = asOptionalTrimmedString(input.currentAccountUserId) ?? null;
-  const resolvedKeyOwner = parseOwnerUserIdFromDbKey(input.dialogKey, {
-    candidateOwnerUserIds: [dialogConfigUserId, currentAccountUserId, "local"]
-  });
-  return dialogConfigUserId ?? resolvedKeyOwner ?? currentAccountUserId ?? "local";
-};
-
-// packages/chat/messages/messageUserPersistAssemble.ts
-function assemblePersistedUserMessage(input) {
-  const {
-    message,
-    dialogId,
-    dialogKey,
-    currentAccountUserId,
-    dialogConfigUserId
-  } = input;
-  const userId = resolveMessageOwner({
-    dialogConfigUserId,
-    dialogKey,
-    currentAccountUserId
-  });
-  const { key: messageDbKey, messageId } = createDialogMessageKeyAndId(
-    dialogId
-  );
-  const fullMessage = {
-    ...message,
-    id: messageId,
-    dbKey: messageDbKey,
-    userId
-  };
-  return { fullMessage, dialogId, dialogKey };
-}
-
-// packages/chat/messages/messageStreamEndAssemble.ts
-function assembleFinalAssistantMessage(input) {
-  const {
-    messageId,
-    msgKey,
-    finalVisibleContent,
-    thinkContent,
-    agentConfig,
-    finalUsageData,
-    toolCalls,
-    finishReason,
-    otherPersistedMessageMetadata,
-    finalMetadata,
-    agentName,
-    userId
-  } = input;
-  const message = {
-    id: messageId,
-    dbKey: msgKey,
-    content: finalVisibleContent,
-    thinkContent,
-    role: "assistant",
-    agentKey: agentConfig.dbKey,
-    cybotKey: agentConfig.dbKey,
-    usage: finalUsageData,
-    isStreaming: false,
-    ...otherPersistedMessageMetadata,
-    ...finalMetadata ? { metadata: finalMetadata } : {},
-    ...agentName ? { agentName } : {},
-    ...toolCalls && toolCalls.length > 0 ? { tool_calls: toolCalls } : {},
-    // finishReason: 只存需要用户知道的值。
-    // "stop" 是正常结束，丢弃；null/undefined 也丢弃，避免写 undefined 进记录。
-    // 保留 "length" / "content_filter" / "tool_calls"，让界面能据此提示截断。
-    ...finishReason && finishReason !== "stop" ? { finishReason } : {},
-    // Authoritative owner last so metadata cannot overwrite it.
-    userId
-  };
-  message.isStreaming = false;
-  message.userId = userId;
-  return message;
-}
-
-// packages/chat/messages/messageStreamApply.ts
-function applyMessageStreamingUpsert(existing, chunk) {
-  const merged = {
-    isStreaming: true,
-    content: "",
-    thinkContent: "",
-    ...chunk
-  };
-  merged.isStreaming = true;
-  if (existing && existing.role === "assistant" && merged.role === "assistant" && typeof existing.content === "string" && existing.content.length > 0 && typeof merged.content === "string" && merged.content.length < existing.content.length && existing.content.startsWith(merged.content)) {
-    merged.content = existing.content;
-  }
-  if (existing && existing.role === "assistant" && merged.role === "assistant" && typeof existing.thinkContent === "string" && existing.thinkContent.length > 0 && typeof merged.thinkContent === "string" && merged.thinkContent.length < existing.thinkContent.length && existing.thinkContent.startsWith(merged.thinkContent)) {
-    merged.thinkContent = existing.thinkContent;
-  }
-  return merged;
-}
-
-// packages/ai/token/missingUsageEstimate.ts
-var APPROX_CHARS_PER_TOKEN = 4;
-var stringifyContent = (content) => {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => {
-      if (typeof part === "string") return part;
-      if (part && typeof part === "object" && "text" in part) {
-        return String(part.text ?? "");
-      }
-      return "";
-    }).join("\n");
-  }
-  if (content == null) return "";
-  return String(content);
-};
-var estimateMissingUsage = ({
-  content,
-  minimumOutputTokens = 1
-}) => {
-  const text = stringifyContent(content);
-  const estimatedOutputTokens = Math.max(
-    minimumOutputTokens,
-    Math.ceil(text.length / APPROX_CHARS_PER_TOKEN)
-  );
-  return {
-    input_tokens: 0,
-    output_tokens: estimatedOutputTokens,
-    cache_creation_input_tokens: 0,
-    cache_read_input_tokens: 0,
-    billing_estimated: true
-  };
-};
-
-// packages/ai/token/openaiImageGenerationUsage.ts
-var isOpenAIBuiltInImageGenerationAgent = (agentConfig) => String(agentConfig?.provider || "").toLowerCase() === "openai" && !getModelInfo(String(agentConfig?.model || ""))?.hasImageOutput && !!agentConfig?.imageConfig?.enabled;
-var withImageGenerationCount = (usage, imageGenerationCount) => {
-  if (!usage || !Number.isFinite(imageGenerationCount) || imageGenerationCount <= 0) {
-    return usage;
-  }
-  const existingCount = asOptionalFiniteNumber(usage.image_generation_count) ?? 0;
-  return {
-    ...usage,
-    image_generation_count: Math.max(existingCount, imageGenerationCount)
-  };
-};
-var countImageGenerationOutputsInContent = (content) => countImageParts(content);
-
-// packages/chat/messages/messageStreamEndBilling.ts
-function resolveStreamEndBillingUsages(input) {
-  const { agentConfig, totalUsage, finalVisibleContent } = input;
-  const imageGenerationCount = countImageGenerationOutputsInContent(finalVisibleContent);
-  const billedUsage = isOpenAIBuiltInImageGenerationAgent(agentConfig) ? withImageGenerationCount(totalUsage, imageGenerationCount) : totalUsage;
-  const rawEstimatedUsage = estimateMissingUsage({
-    content: finalVisibleContent
-  });
-  const providerCallId = typeof totalUsage === "object" && totalUsage !== null ? totalUsage.provider_call_id : void 0;
-  const estimatedUsage = providerCallId ? { ...rawEstimatedUsage, provider_call_id: providerCallId } : rawEstimatedUsage;
-  const billedEstimatedUsage = isOpenAIBuiltInImageGenerationAgent(agentConfig) ? withImageGenerationCount(estimatedUsage, imageGenerationCount) : estimatedUsage;
-  const titleEligibleContent = serializeMessageContent(finalVisibleContent, "[\u56FE\u7247]") ?? "";
-  const hasReportedTokens = Boolean(
-    totalUsage && typeof totalUsage === "object" && ([
-      "prompt_tokens",
-      "completion_tokens",
-      "total_tokens",
-      "input_tokens",
-      "output_tokens"
-    ].some((field) => Object.prototype.hasOwnProperty.call(totalUsage, field)) || Object.prototype.hasOwnProperty.call(totalUsage, "cost") && typeof totalUsage.cost === "number")
-  );
-  return {
-    imageGenerationCount,
-    billedUsage,
-    billedEstimatedUsage,
-    hasReportedUsage: hasReportedTokens,
-    titleEligible: titleEligibleContent.trim() !== ""
-  };
-}
-
-// packages/chat/messages/web/toolDisplayName.ts
-var LEGACY_VERSION_ACTIVITY_TITLES = {
-  \u7528\u7248\u672C\u7BA1\u7406\u68C0\u67E5\u6539\u52A8: "\u68C0\u67E5\u6539\u52A8",
-  \u7528\u7248\u672C\u7BA1\u7406\u67E5\u770B\u6539\u52A8: "\u67E5\u770B\u6539\u52A8",
-  \u7528\u7248\u672C\u7BA1\u7406\u67E5\u770B\u5386\u53F2: "\u67E5\u770B\u5386\u53F2",
-  \u7528\u7248\u672C\u7BA1\u7406\u6682\u5B58\u6539\u52A8: "\u6682\u5B58",
-  \u7528\u7248\u672C\u7BA1\u7406\u4FDD\u5B58\u6539\u52A8: "\u63D0\u4EA4",
-  \u7528\u7248\u672C\u7BA1\u7406\u540C\u6B65\u6539\u52A8: "\u63A8\u9001"
-};
-function shortenActivityTitle(title) {
-  const trimmed = title.trim();
-  if (!trimmed) return trimmed;
-  const mapped = LEGACY_VERSION_ACTIVITY_TITLES[trimmed];
-  if (mapped) return mapped;
-  if (trimmed.startsWith("\u7528\u7248\u672C\u7BA1\u7406")) {
-    const rest = trimmed.slice("\u7528\u7248\u672C\u7BA1\u7406".length).trim();
-    return rest || trimmed;
-  }
-  return trimmed;
-}
-function extractToolCallArgs(toolPayload) {
-  if (isRecord(toolPayload?.input)) {
-    return toolPayload.input;
-  }
-  const rawArguments = toolPayload?.rawToolCall;
-  if (isRecord(rawArguments)) {
-    const fn = rawArguments.function;
-    if (isRecord(fn)) {
-      const argumentsText = asTrimmedString(fn.arguments);
-      if (argumentsText) {
-        const parsed = asOptionalJsonRecord(argumentsText);
-        if (parsed) return parsed;
-      }
-    }
-  }
-  return void 0;
-}
-var SHELL_COMMAND_CLASSIFIERS = [
-  {
-    pattern: /\bgit\s+(status)\b/,
-    label: () => "\u68C0\u67E5\u6539\u52A8"
-  },
-  {
-    pattern: /\bgit\s+diff\b/,
-    label: () => "\u67E5\u770B\u6539\u52A8"
-  },
-  {
-    pattern: /\bgit\s+log\b/,
-    label: () => "\u67E5\u770B\u5386\u53F2"
-  },
-  {
-    pattern: /\bgit\s+add\b/,
-    label: () => "\u6682\u5B58"
-  },
-  {
-    pattern: /\bgit\s+commit\b/,
-    label: () => "\u63D0\u4EA4"
-  },
-  {
-    pattern: /\bgit\s+push\b/,
-    label: () => "\u63A8\u9001"
-  },
-  {
-    pattern: /\bgit\s+pull\b/,
-    label: () => "\u62C9\u53D6"
-  },
-  {
-    pattern: /\bgit\s+fetch\b/,
-    label: () => "\u83B7\u53D6\u66F4\u65B0"
-  },
-  {
-    pattern: /\bgit\s+checkout\b|\bgit\s+switch\b/,
-    label: () => "\u5207\u6362\u5206\u652F"
-  },
-  {
-    pattern: /\bgit\s+branch\b/,
-    label: () => "\u67E5\u770B\u5206\u652F"
-  },
-  {
-    pattern: /\bgit\s+stash\b/,
-    label: () => "\u8D2E\u85CF"
-  },
-  {
-    pattern: /\bgit\s+merge\b/,
-    label: () => "\u5408\u5E76"
-  },
-  {
-    pattern: /\bgit\s+rebase\b/,
-    label: () => "\u53D8\u57FA"
-  },
-  {
-    pattern: /\bgit\s+clone\b/,
-    label: () => "\u514B\u9686"
-  },
-  {
-    pattern: /\bgit\s+remote\b/,
-    label: () => "\u8FDC\u7A0B"
-  },
-  {
-    pattern: /\bgit\s+reset\b/,
-    label: () => "\u91CD\u7F6E"
-  },
-  {
-    pattern: /\bgit\s+restore\b/,
-    label: () => "\u8FD8\u539F"
-  },
-  {
-    pattern: /\bgit\b/,
-    label: () => "\u7248\u672C\u64CD\u4F5C"
-  },
-  {
-    pattern: /\b(rg|grep)\b/,
-    label: (cmd) => {
-      const match = cmd.match(/(?:rg|grep)\s+(?:-[^\s]*\s+)*['"]?([^\s'"]+)['"]?/);
-      return match ? `\u641C\u7D22 "${match[1]}"` : "\u641C\u7D22\u4EE3\u7801";
-    }
-  },
-  {
-    pattern: /\b(bun\s+test|jest|vitest|mocha|pytest|go\s+test)\b/,
-    label: () => "\u8FD0\u884C\u6D4B\u8BD5"
-  },
-  {
-    pattern: /\b(bun\s+run\s+build|npm\s+run\s+build|yarn\s+build|make\s+build)\b/,
-    label: () => "\u6784\u5EFA\u9879\u76EE"
-  },
-  {
-    pattern: /\b(bun\s+install|npm\s+install|yarn\s+install|pnpm\s+install)\b/,
-    label: () => "\u5B89\u88C5\u4F9D\u8D56"
-  },
-  {
-    pattern: /\b(bun\s+run\s+dev|npm\s+run\s+dev|yarn\s+dev)\b/,
-    label: () => "\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668"
-  },
-  {
-    pattern: /\bcurl\b/,
-    label: (cmd) => {
-      const match = cmd.match(/curl\s+(?:-[^\s]*\s+)*(https?:\/\/[^\s'"]+)/);
-      return match ? `\u8BF7\u6C42 ${match[1]}` : "\u53D1\u9001 HTTP \u8BF7\u6C42";
-    }
-  },
-  {
-    pattern: /\blsof\b/,
-    label: () => "\u67E5\u770B\u7AEF\u53E3\u5360\u7528"
-  }
-];
-function classifyShellCommand(command) {
-  const trimmed = command.trim();
-  for (const { pattern, label } of SHELL_COMMAND_CLASSIFIERS) {
-    if (pattern.test(trimmed)) return label(trimmed);
-  }
-  return "\u8FD0\u884C\u547D\u4EE4";
-}
-function buildFallbackActivity(toolName, args) {
-  const normalized = asTrimmedString(toolName);
-  if (!normalized || !args) return void 0;
-  switch (normalized) {
-    case "readFile": {
-      const path = asTrimmedString(args.path);
-      return path ? { title: "\u67E5\u770B\u76F8\u5173\u6587\u4EF6", refs: [{ type: "file", path }] } : void 0;
-    }
-    case "writeFile": {
-      const path = asTrimmedString(args.path);
-      return path ? { title: "\u5199\u5165\u6587\u4EF6", refs: [{ type: "file", path }] } : void 0;
-    }
-    case "editFile": {
-      const path = asTrimmedString(args.path);
-      return path ? { title: "\u4FEE\u6539\u6587\u4EF6", refs: [{ type: "file", path }] } : void 0;
-    }
-    case "codeSearch":
-    case "code_search": {
-      const query = asTrimmedString(args.query);
-      return query ? { title: "\u5728\u4EE3\u7801\u91CC\u627E\u7EBF\u7D22", detail: query } : void 0;
-    }
-    case "globFiles": {
-      const pattern = asTrimmedString(
-        typeof args.pattern === "string" ? args.pattern : args.glob
-      );
-      return pattern ? { title: "\u67E5\u627E\u76F8\u5173\u6587\u4EF6", detail: pattern } : void 0;
-    }
-    case "loadSkill": {
-      const name = asTrimmedString(args.name);
-      return name ? { title: "\u52A0\u8F7D\u6280\u80FD", detail: name } : void 0;
-    }
-    case "execShell": {
-      const command = asTrimmedString(
-        typeof args.cmd === "string" ? args.cmd : args.command
-      );
-      if (!command) return void 0;
-      const label = classifyShellCommand(command);
-      return { title: label, detail: command.length <= 120 ? command : `${command.slice(0, 117)}...` };
-    }
-    default:
-      return void 0;
-  }
-}
-function normalizeString(value) {
-  return asOptionalTrimmedString(value);
-}
-function normalizeStatus(value) {
-  return value === "pending" || value === "running" || value === "success" || value === "failed" ? value : void 0;
-}
-function normalizeKind(value) {
-  return value === "read" || value === "write" || value === "edit" || value === "search" || value === "terminal" || value === "version" || value === "test" || value === "build" || value === "preview" || value === "other" ? value : void 0;
-}
-function normalizeRefs(value) {
-  if (!Array.isArray(value)) return void 0;
-  const refs = value.flatMap((item) => {
-    if (!isRecord(item)) return [];
-    if (item.type === "file") {
-      const path = normalizeString(item.path);
-      return path ? [{ type: "file", path }] : [];
-    }
-    if (item.type === "terminal") {
-      const id = normalizeString(item.id);
-      const label = normalizeString(item.label);
-      return id || label ? [{ type: "terminal", ...id ? { id } : {}, ...label ? { label } : {} }] : [];
-    }
-    if (item.type === "url") {
-      const url = normalizeString(item.url);
-      const label = normalizeString(item.label);
-      return url ? [{ type: "url", url, ...label ? { label } : {} }] : [];
-    }
-    return [];
-  });
-  return refs.length ? refs : void 0;
-}
-function normalizeActivityAction(value) {
-  if (!isRecord(value)) return void 0;
-  const title = normalizeString(value.title);
-  if (!title) return void 0;
-  const detail = normalizeString(value.detail);
-  const kind = normalizeKind(value.kind);
-  const refs = normalizeRefs(value.refs);
-  return {
-    title: shortenActivityTitle(title),
-    ...kind ? { kind } : {},
-    ...detail ? { detail } : {},
-    ...refs ? { refs } : {}
-  };
-}
-function normalizeActivityPhase(value) {
-  if (!isRecord(value)) return void 0;
-  const title = normalizeString(value.title);
-  if (!title) return void 0;
-  const id = normalizeString(value.id) || title.toLowerCase().replace(/\s+/g, "-");
-  const index = asOptionalFiniteNumber(value.index);
-  const total = asOptionalFiniteNumber(value.total);
-  const status = normalizeStatus(value.status);
-  return {
-    id,
-    title,
-    ...index !== void 0 ? { index } : {},
-    ...total !== void 0 ? { total } : {},
-    ...status ? { status } : {}
-  };
-}
-function normalizeActivityPlan(value) {
-  if (!isRecord(value)) return void 0;
-  if (!Array.isArray(value.phases)) return void 0;
-  const phases = value.phases.flatMap((item, index) => {
-    const phase = normalizeActivityPhase(item);
-    if (!phase) return [];
-    return [{
-      id: phase.id,
-      title: phase.title,
-      index: phase.index ?? index + 1,
-      ...phase.status ? { status: phase.status } : {}
-    }];
-  });
-  if (phases.length === 0) return void 0;
-  const title = normalizeString(value.title);
-  return {
-    ...title ? { title } : {},
-    phases
-  };
-}
-function normalizeActivitySignal(value) {
-  if (!isRecord(value)) return void 0;
-  const nestedAction = normalizeActivityAction(value.action);
-  const legacyAction = normalizeActivityAction(value);
-  const action2 = nestedAction || legacyAction;
-  const phase = normalizeActivityPhase(value.phase);
-  const plan = normalizeActivityPlan(value.plan);
-  if (!action2 && !phase && !plan) return void 0;
-  return {
-    ...action2 ? { action: action2 } : {},
-    ...phase ? { phase } : {},
-    ...plan ? { plan } : {}
-  };
-}
-function normalizeToolActivity(value) {
-  const signal = normalizeActivitySignal(value);
-  if (!signal?.action) return void 0;
-  return {
-    ...signal.action,
-    ...signal.phase ? { phase: signal.phase } : {},
-    ...signal.action ? { action: signal.action } : {},
-    ...signal.plan ? { plan: signal.plan } : {}
-  };
-}
-function formatActivityAction(activity) {
-  const firstRef = activity.refs?.[0];
-  const refLabel = firstRef?.type === "file" ? firstRef.path : firstRef?.type === "terminal" ? firstRef.label || firstRef.id : firstRef?.type === "url" ? firstRef.label || firstRef.url : void 0;
-  const suffix = refLabel || activity.detail;
-  return suffix ? `${activity.title} \xB7 ${suffix}` : activity.title;
-}
-function getMessageStatus(msg) {
-  const rawData = typeof msg?.content === "string" ? asOptionalJsonRecord(msg.content) : msg?.content;
-  const isError = msg?.toolPayload?.status === "failed" || !!msg?.toolPayload?.error || !!rawData?.error;
-  if (msg?.isStreaming || msg?.toolPayload?.status === "running") return "running";
-  if (isError) return "failed";
-  if (msg?.toolPayload?.status === "pending") return "pending";
-  return "success";
-}
-function mergeStatuses(current, next) {
-  if (current === "running" || next === "running") return "running";
-  if (current === "failed" || next === "failed") return "failed";
-  if (current === "pending" || next === "pending") return "pending";
-  return "success";
-}
-function readMessageActivitySignal(msg) {
-  const meta = msg.metadata;
-  const explicit = normalizeActivitySignal(meta?.activity) || normalizeActivitySignal(msg.toolPayload?.activity);
-  if (explicit) return explicit;
-  const parsedArgs = tryParseToolArgs(msg);
-  const fallback = buildFallbackActivity(msg.toolName, parsedArgs);
-  const fallbackActivity = fallback ? normalizeToolActivity(fallback) : void 0;
-  return fallbackActivity ? {
-    action: fallbackActivity.action || fallbackActivity,
-    ...fallbackActivity.phase ? { phase: fallbackActivity.phase } : {},
-    ...fallbackActivity.plan ? { plan: fallbackActivity.plan } : {}
-  } : void 0;
-}
-function readMessageActivityPlan(msg) {
-  const meta = msg.metadata;
-  const metadataActivity = isRecord(meta?.activity) ? meta.activity : void 0;
-  const payloadActivity = isRecord(msg.toolPayload?.activity) ? msg.toolPayload.activity : void 0;
-  return normalizeActivitySignal(metadataActivity)?.plan || normalizeActivitySignal(payloadActivity)?.plan;
-}
-function buildActivityTimeline(messages, activityPlan, options = {}) {
-  const phases = [];
-  const phaseById = /* @__PURE__ */ new Map();
-  let implicitPhase;
-  let declaredTotal = 0;
-  const includePlan = options.includePlan !== false;
-  const declaredPlan = includePlan ? normalizeActivityPlan(activityPlan) || messages.map(readMessageActivityPlan).find(Boolean) : void 0;
-  const ensurePlanPhase = (phaseDef) => {
-    let phase = phaseById.get(phaseDef.id);
-    if (!phase) {
-      phase = {
-        id: phaseDef.id,
-        title: phaseDef.title,
-        ...phaseDef.index !== void 0 ? { index: phaseDef.index } : {},
-        ...declaredPlan ? { total: declaredPlan.phases.length } : {},
-        status: phaseDef.status || "pending",
-        actions: []
-      };
-      phaseById.set(phaseDef.id, phase);
-      phases.push(phase);
-    }
-    return phase;
-  };
-  if (declaredPlan) {
-    declaredTotal = declaredPlan.phases.length;
-    for (const phaseDef of declaredPlan.phases) {
-      ensurePlanPhase(phaseDef);
-    }
-  }
-  for (const msg of messages) {
-    const signal = readMessageActivitySignal(msg);
-    if (!signal) continue;
-    if (includePlan && !declaredPlan && signal.plan) {
-      declaredTotal = Math.max(declaredTotal, signal.plan.phases.length);
-      for (const phaseDef2 of signal.plan.phases) {
-        ensurePlanPhase(phaseDef2);
-      }
-    }
-    const status = getMessageStatus(msg);
-    const activityAction = signal.action;
-    const phaseDef = signal.phase;
-    if (!activityAction && !phaseDef) continue;
-    const phaseId = phaseDef?.id || "__implicit_tools__";
-    const phaseTitle = phaseDef?.title || "\u6267\u884C\u5DE5\u5177\u6B65\u9AA4";
-    const phaseStatus = phaseDef?.status || (activityAction ? status : "pending");
-    let phase = phaseById.get(phaseId);
-    if (!phase) {
-      phase = {
-        id: phaseId,
-        title: phaseTitle,
-        ...phaseDef?.index !== void 0 ? { index: phaseDef.index } : {},
-        ...phaseDef?.total !== void 0 ? { total: phaseDef.total } : {},
-        status: phaseStatus,
-        actions: []
-      };
-      phaseById.set(phaseId, phase);
-      phases.push(phase);
-      if (!phaseDef) implicitPhase = phase;
-    } else {
-      phase.status = mergeStatuses(phase.status, phaseStatus);
-      if (phase.status === "pending") {
-        phase.status = phaseStatus;
-      }
-    }
-    if (phaseDef?.total && phaseDef.total > declaredTotal) {
-      declaredTotal = phaseDef.total;
-    }
-    if (activityAction) {
-      const action2 = {
-        ...activityAction,
-        id: normalizeString(msg.id) || normalizeString(msg.dbKey) || normalizeString(msg.toolCallId) || normalizeString(msg.tool_call_id) || `tool-action-${phase.actions.length + 1}`,
-        label: formatActivityAction(activityAction),
-        status,
-        message: msg
-      };
-      phase.actions.push(action2);
-    }
-  }
-  if (implicitPhase && phases.length > 1 && implicitPhase.actions.length === 0) {
-    phaseById.delete(implicitPhase.id);
-  }
-  const completedPhases = phases.filter((phase) => phase.status === "success").length;
-  return {
-    phases,
-    completedPhases,
-    totalPhases: declaredTotal || phases.length
-  };
-}
-function tryParseToolArgs(msg) {
-  const payloadArgs = extractToolCallArgs(msg.toolPayload);
-  if (payloadArgs) return payloadArgs;
-  const meta = msg.metadata;
-  if (meta) {
-    const derived = {};
-    let hasField = false;
-    const path = normalizeString(meta.path);
-    if (path) {
-      derived.path = path;
-      hasField = true;
-    }
-    const command = normalizeString(meta.command);
-    if (command) {
-      derived.command = command;
-      hasField = true;
-    }
-    const cmd = normalizeString(meta.cmd);
-    if (cmd) {
-      derived.cmd = cmd;
-      hasField = true;
-    }
-    const query = normalizeString(meta.query);
-    if (query) {
-      derived.query = query;
-      hasField = true;
-    }
-    const pattern = normalizeString(meta.pattern);
-    if (pattern) {
-      derived.pattern = pattern;
-      hasField = true;
-    }
-    if (hasField) return derived;
-  }
-  const content = normalizeString(msg.content);
-  if (content) {
-    try {
-      const parsed = JSON.parse(content);
-      if (isRecord(parsed)) {
-        return parsed;
-      }
-    } catch {
-    }
-  }
-  return void 0;
-}
-
-// packages/chat/messages/activityCompletion.ts
-var FINAL_DELIVERY_PHASE_PATTERNS = [
-  /汇报/,
-  /回复/,
-  /总结/,
-  /结果/,
-  /交付/,
-  /可视化/,
-  /图表/,
-  /report/i,
-  /deliver/i,
-  /result/i,
-  /summary/i,
-  /visual/i,
-  /chart/i
-];
-var FAILED_FINAL_CONTENT_PATTERNS = [
-  /抱歉/,
-  /无法/,
-  /不能/,
-  /失败/,
-  /出错/,
-  /未完成/,
-  /cannot/i,
-  /can't/i,
-  /failed/i,
-  /error/i,
-  /unable/i
-];
-function isLikelyFinalDeliveryPhase(title) {
-  return FINAL_DELIVERY_PHASE_PATTERNS.some((pattern) => pattern.test(title));
-}
-function isLikelyFailedFinalContent(text) {
-  return FAILED_FINAL_CONTENT_PATTERNS.some((pattern) => pattern.test(text));
-}
-function inferAssistantActivityCompletionMetadata({
-  messages,
-  finalContent
-}) {
-  const finalText = serializeMessageContent(finalContent, "[\u56FE\u7247]")?.trim();
-  if (!finalText || isLikelyFailedFinalContent(finalText)) return void 0;
-  const timeline = buildActivityTimeline(messages);
-  if (timeline.totalPhases <= 1 || timeline.completedPhases >= timeline.totalPhases) {
-    return void 0;
-  }
-  const finalPhase = timeline.phases[timeline.phases.length - 1];
-  if (!finalPhase || finalPhase.status !== "pending") return void 0;
-  const priorPhases = timeline.phases.slice(0, -1);
-  if (priorPhases.length === 0 || priorPhases.some((phase) => phase.status !== "success")) {
-    return void 0;
-  }
-  if (!isLikelyFinalDeliveryPhase(finalPhase.title)) return void 0;
-  return {
-    activity: {
-      phase: {
-        id: finalPhase.id,
-        title: finalPhase.title,
-        ...finalPhase.index !== void 0 ? { index: finalPhase.index } : {},
-        ...finalPhase.total !== void 0 ? { total: finalPhase.total } : {},
-        status: "success"
-      }
-    }
-  };
-}
-
-// packages/chat/messages/messageStreamEndFinalMetadata.ts
-function resolveStreamEndFinalMetadata(input) {
-  const { persistedMetadata, toolCalls, messages, finalContent } = input;
-  const shouldInfer = !persistedMetadata?.activity && (!toolCalls || toolCalls.length === 0);
-  const inferred = shouldInfer ? inferAssistantActivityCompletionMetadata({
-    messages,
-    finalContent
-  }) : void 0;
-  const finalMetadata = inferred ? { ...persistedMetadata ?? {}, ...inferred } : persistedMetadata ?? void 0;
-  return { finalMetadata };
-}
-
-// packages/chat/messages/messageStreamEndPostWritePolicy.ts
-function resolveStreamEndPostWritePolicy(input) {
-  const { hasReportedUsage, billingFailed, skipBilling, agentProvider, titleEligible, textContent, toolCalls } = input;
-  const billingMode = billingFailed || skipBilling ? "skip" : hasReportedUsage ? "reported" : agentProvider && agentProvider !== "custom" ? "estimated" : "skip";
-  const hasText = textContent.trim() !== "";
-  const noTools = !toolCalls || toolCalls.length === 0;
-  return {
-    billingMode,
-    updateTitle: titleEligible,
-    updateSummary: hasText,
-    addRefs: hasText,
-    summaryForce: noTools,
-    summaryReason: noTools ? "task_completed" : "context_budget"
-  };
-}
-
-// packages/chat/messages/messageStreamEndBillingDispatch.ts
-async function dispatchStreamEndBilling(input) {
-  const {
-    dispatch,
-    updateTokensAction: updateTokensAction2,
-    billingMode,
-    billingUsageRecords,
-    billedUsage,
-    billedEstimatedUsage,
-    dialogId,
-    dialogKey,
-    agentConfig
-  } = input;
-  try {
-    if (billingMode === "reported") {
-      const fallbackCallId = typeof billedUsage?.provider_call_id === "string" && billedUsage.provider_call_id.trim() ? billedUsage.provider_call_id.trim() : void 0;
-      const usageRecords = billingUsageRecords?.length ? billingUsageRecords : [{ callId: fallbackCallId, usage: billedUsage }];
-      for (const usageRecord of usageRecords) {
-        await dispatch(
-          updateTokensAction2({
-            dialogId,
-            dialogKey,
-            usageRecord,
-            agentConfig
-          })
-        ).unwrap();
-      }
-    } else if (billingMode === "estimated") {
-      await dispatch(
-        updateTokensAction2({
-          dialogId,
-          dialogKey,
-          usage: billedEstimatedUsage,
-          agentConfig
-        })
-      ).unwrap();
-      console.warn(
-        "[billing] Missing usage at messageStreamEnd; using estimated token update",
-        {
-          dialogId,
-          dialogKey,
-          provider: agentConfig.provider,
-          model: agentConfig.model,
-          endpointKey: agentConfig.endpointKey
-        }
-      );
-    }
-  } catch (billingError) {
-    console.error(
-      "[billing] updateTokens failed (best-effort, message already saved):",
-      billingError
-    );
-  }
-}
-
-// packages/chat/messages/messageStreamEndPersistPrep.ts
-function prepareStreamEndPersistInputs(input) {
-  const { totalUsage, agentConfig, messageMetadata } = input;
-  const completionTokens = totalUsage?.completion_tokens ?? totalUsage?.output_tokens;
-  const finalUsageData = totalUsage && completionTokens != null ? { completion_tokens: completionTokens } : void 0;
-  const agentName = asTrimmedString(agentConfig?.name) || void 0;
-  const {
-    imageGenerationState: _transientImageGenerationState,
-    ...persistedMessageMetadata
-  } = messageMetadata ?? {};
-  const {
-    metadata: persistedMetadata,
-    ...otherPersistedMessageMetadata
-  } = persistedMessageMetadata;
-  return {
-    finalUsageData,
-    agentName,
-    persistedMetadata,
-    otherPersistedMessageMetadata
-  };
-}
-
-// packages/chat/messages/messageUnderstandingCapture.ts
-function getLatestUserInputFromMessages(messages) {
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (!message || message.role !== "user") continue;
-    const serialized = serializeMessageContent(message.content, "[\u56FE\u7247]")?.trim();
-    if (serialized) return serialized;
-  }
-  return null;
-}
-function getDialogSpaceIdFromState(state, dialogKey) {
-  if (!dialogKey) return void 0;
-  const dialog = selectById(state, dialogKey);
-  return typeof dialog?.spaceId === "string" ? dialog.spaceId : void 0;
-}
-function resolveMemoryCaptureBaseUrl(state) {
-  const currentServer = typeof state?.settings?.currentServer === "string" ? state.settings.currentServer : null;
-  const _window = globalThis.window;
-  if (!_window) return (currentServer || "").replace(/\/+$/, "");
-  if (!currentServer) return _window.location.origin;
-  return currentServer.replace(/\/+$/, "");
-}
-async function captureUnderstandingFromCompletedUiTurn(input) {
-  if (input.assistantText.trim() === "") return;
-  if (input.toolCalls && input.toolCalls.length > 0) return;
-  if (!input.agentKey) return;
-  const latestUserInput = getLatestUserInputFromMessages(input.messages);
-  if (!latestUserInput) return;
-  const state = input.state;
-  const token = selectIdentityToken(state) ?? null;
-  const baseUrl = resolveMemoryCaptureBaseUrl(state);
-  if (!token || !baseUrl) return;
-  const dialog = input.dialogKey ? selectById(state, input.dialogKey) : void 0;
-  try {
-    await fetch(`${baseUrl}/api/memory/capture-turn`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({
-        agentKey: input.agentKey,
-        dialogId: input.dialogId,
-        userInput: latestUserInput,
-        assistantText: input.assistantText,
-        spaceId: input.spaceId ?? getDialogSpaceIdFromState(state, input.dialogKey)
-      })
-    });
-  } catch {
-  }
-}
-
-// packages/chat/messages/messageSessionStore.ts
-var import_react = __toESM(require_react());
-var GLOBAL_MESSAGE_DIALOG_ID = "__global__";
-var createEmptyMessageSessionState = () => ({
-  firstStreamProcessed: false,
-  isLoadingInitial: false,
-  isLoadingOlder: false,
-  hasMoreOlder: true,
-  error: null,
-  lastStreamTimestamp: 0,
-  currentInitMsgsRequestId: void 0,
-  currentLoadOlderRequestId: void 0,
-  streamingMessageId: null,
-  lastAbortTimestamp: 0
-});
-var activeDialogId = null;
-var sessionByDialogId = {
-  [GLOBAL_MESSAGE_DIALOG_ID]: createEmptyMessageSessionState()
-};
-var listeners = /* @__PURE__ */ new Set();
-var version = 0;
-var notify = () => {
-  version += 1;
-  for (const listener of listeners) {
-    try {
-      listener();
-    } catch {
-    }
-  }
-};
-var action = (type, payload) => ({ type, payload });
-function setActiveMessageDialogId(dialogId) {
-  activeDialogId = dialogId;
-  notify();
-}
-function getActiveMessageDialogId() {
-  return activeDialogId;
-}
-var resolveDialogId = (dialogId) => dialogId ?? activeDialogId ?? GLOBAL_MESSAGE_DIALOG_ID;
-function ensureMessageSession(dialogId) {
-  const key = resolveDialogId(dialogId);
-  if (!sessionByDialogId[key]) {
-    sessionByDialogId[key] = createEmptyMessageSessionState();
-  }
-  return sessionByDialogId[key];
-}
-function getMessageSession(dialogId) {
-  return sessionByDialogId[resolveDialogId(dialogId)] ?? createEmptyMessageSessionState();
-}
-function patchMessageSession(dialogId, patch2) {
-  const session = ensureMessageSession(dialogId);
-  Object.assign(session, patch2);
-  notify();
-  return action("messageSession/patch", { dialogId, patch: patch2 });
-}
-function deleteMessageSession(dialogId) {
-  delete sessionByDialogId[dialogId];
-  if (activeDialogId === dialogId) {
-    activeDialogId = null;
-  }
-  if (!sessionByDialogId[GLOBAL_MESSAGE_DIALOG_ID]) {
-    sessionByDialogId[GLOBAL_MESSAGE_DIALOG_ID] = createEmptyMessageSessionState();
-  }
-  notify();
-  return action("messageSession/delete", { dialogId });
-}
-function resetAllMessageSessions() {
-  for (const key of Object.keys(sessionByDialogId)) {
-    delete sessionByDialogId[key];
-  }
-  sessionByDialogId[GLOBAL_MESSAGE_DIALOG_ID] = createEmptyMessageSessionState();
-  activeDialogId = null;
-  notify();
-  return action("messageSession/resetAll");
-}
-function markMessageStreamActivity(dialogId) {
-  const session = ensureMessageSession(dialogId);
-  session.firstStreamProcessed = true;
-  session.lastStreamTimestamp = Date.now();
-  notify();
-  return action("messageSession/streamActivity", { dialogId });
-}
-function markMessageSessionAbort(dialogId) {
-  const session = ensureMessageSession(dialogId);
-  session.lastAbortTimestamp = Date.now();
-  notify();
-  return action("messageSession/abort", { dialogId });
-}
-function setStreamingMessageId(dialogId, messageId) {
-  const session = ensureMessageSession(dialogId);
-  if (session.streamingMessageId === messageId) return;
-  session.streamingMessageId = messageId;
-  notify();
-}
-function getHasStreamingMessage(dialogId) {
-  if (dialogId === null) return false;
-  return !!getMessageSession(dialogId).streamingMessageId;
-}
-var selectCurrentDialogId = (_state) => getActiveMessageDialogId();
-
-// packages/chat/messages/messageSlice.ts
-var OLDER_LOAD_LIMIT = 30;
-var createSliceWithThunks = buildCreateSlice({
-  creators: { asyncThunk: asyncThunkCreator }
-});
-var messagesAdapter = createEntityAdapter({
-  selectId: (message) => message.id,
-  sortComparer: (a, b) => a.id.localeCompare(b.id)
-});
-var createEmptyMessageDialogState = () => ({
-  msgs: messagesAdapter.getInitialState()
-});
-var initialState = {
-  dialogStateById: {
-    [GLOBAL_MESSAGE_DIALOG_ID]: createEmptyMessageDialogState()
-  }
-};
-var captureUnderstandingFromCompletedUiTurn2 = async (input) => captureUnderstandingFromCompletedUiTurn({
-  ...input,
-  messages: input.messages ?? selectAllMsgs(input.state, input.dialogId)
-});
-var resolveMessageDialogId = (_state, dialogId, dialogKey) => dialogId ?? (dialogKey ? extractCustomId(dialogKey) : null) ?? getActiveMessageDialogId() ?? GLOBAL_MESSAGE_DIALOG_ID;
-var ensureMessageDialogState = (state, dialogId, dialogKey) => {
-  const resolvedDialogId = resolveMessageDialogId(state, dialogId, dialogKey);
-  if (!state.dialogStateById) {
-    state.dialogStateById = {
-      [GLOBAL_MESSAGE_DIALOG_ID]: createEmptyMessageDialogState()
-    };
-  }
-  if (!state.dialogStateById[resolvedDialogId]) {
-    state.dialogStateById[resolvedDialogId] = createEmptyMessageDialogState();
-  }
-  return state.dialogStateById[resolvedDialogId];
-};
-var getMessageDialogState = (state, dialogId, dialogKey) => {
-  const dialogStateById = state.dialogStateById ?? {};
-  const resolvedDialogId = resolveMessageDialogId(state, dialogId, dialogKey);
-  const bucket = dialogStateById[resolvedDialogId];
-  if (bucket) return bucket;
-  const legacyMsgs = state.msgs;
-  if (legacyMsgs && typeof legacyMsgs === "object") {
-    return { msgs: legacyMsgs };
-  }
-  return createEmptyMessageDialogState();
-};
-var inferDialogIdFromDbKey = (dbKey) => {
-  if (!dbKey) return null;
-  const parts = dbKey.split("-");
-  if (parts.length >= 4 && parts[0] === "dialog" /* DIALOG */ && parts[2] === "msg") {
-    return parts[1];
-  }
-  return null;
-};
-var inferDialogIdFromMessage = (message) => message.dialogId ?? inferDialogIdFromDbKey(message.dbKey);
-var findDialogIdByMessageId = (state, messageId) => {
-  for (const [dialogId, dialogState] of Object.entries(state.dialogStateById)) {
-    if (dialogState.msgs.entities[messageId]) {
-      return dialogId;
-    }
-  }
-  return null;
-};
-var findDialogIdByMessageDbKey = (state, dbKey) => {
-  for (const [dialogId, dialogState] of Object.entries(state.dialogStateById)) {
-    const hasDbKey = Object.values(dialogState.msgs.entities).some(
-      (message) => message?.dbKey === dbKey
-    );
-    if (hasDbKey) {
-      return dialogId;
-    }
-  }
-  return inferDialogIdFromDbKey(dbKey);
-};
-var upsertOneMessage = (dialogState, message) => {
-  dialogState.msgs = messagesAdapter.upsertOne(
-    dialogState.msgs,
-    normalizeHistoricalReasoningMessage(message)
-  );
-};
-var upsertManyMessages = (dialogState, messages) => {
-  dialogState.msgs = messagesAdapter.upsertMany(
-    dialogState.msgs,
-    messages.map(normalizeHistoricalReasoningMessage)
-  );
-};
-var addOneMessage = (dialogState, message) => {
-  dialogState.msgs = messagesAdapter.addOne(
-    dialogState.msgs,
-    normalizeHistoricalReasoningMessage(message)
-  );
-};
-var updateOneMessage = (dialogState, payload) => {
-  dialogState.msgs = messagesAdapter.updateOne(dialogState.msgs, payload);
-};
-var updateManyMessages = (dialogState, payload) => {
-  dialogState.msgs = messagesAdapter.updateMany(dialogState.msgs, payload);
-};
-var removeOneMessage = (dialogState, messageId) => {
-  dialogState.msgs = messagesAdapter.removeOne(dialogState.msgs, messageId);
-};
-var removeAllMessages = (dialogState) => {
-  dialogState.msgs = messagesAdapter.removeAll(dialogState.msgs);
-};
-var setAllMessages = (dialogState, messages) => {
-  dialogState.msgs = messagesAdapter.setAll(
-    dialogState.msgs,
-    messages.map(normalizeHistoricalReasoningMessage)
-  );
-};
-var messageActions;
-var messageSlice = createSliceWithThunks({
-  name: "message",
-  initialState,
-  reducers: (create) => ({
-    addUserMessage: create.reducer((state, action2) => {
-      const { dialogId, ...message } = action2.payload;
-      const dialogState = ensureMessageDialogState(
-        state,
-        dialogId ?? inferDialogIdFromMessage(action2.payload)
-      );
-      upsertOneMessage(dialogState, {
-        ...message,
-        isStreaming: false
-      });
-    }),
-    messageStreaming: create.reducer(
-      (state, action2) => {
-        const { dialogId, ...message } = action2.payload;
-        const resolvedDialogId = dialogId ?? inferDialogIdFromMessage(action2.payload);
-        const dialogState = ensureMessageDialogState(state, resolvedDialogId);
-        const existing = dialogState.msgs.entities[message.id];
-        upsertOneMessage(
-          dialogState,
-          applyMessageStreamingUpsert(existing, message)
-        );
-        setStreamingMessageId(resolvedDialogId, message.id);
-        markMessageStreamActivity(resolvedDialogId);
-      }
-    ),
-    resetMsgs: create.reducer((state, action2) => {
-      if (action2.payload?.all) {
-        state.dialogStateById = {
-          [GLOBAL_MESSAGE_DIALOG_ID]: createEmptyMessageDialogState()
-        };
-        resetAllMessageSessions();
-        return;
-      }
-      const dialogId = resolveMessageDialogId(
-        state,
-        action2.payload?.dialogId,
-        action2.payload?.dialogKey
-      );
-      delete state.dialogStateById[dialogId];
-      deleteMessageSession(dialogId);
-      if (dialogId === getActiveMessageDialogId()) {
-        setActiveMessageDialogId(null);
-      }
-      if (!state.dialogStateById[GLOBAL_MESSAGE_DIALOG_ID]) {
-        state.dialogStateById[GLOBAL_MESSAGE_DIALOG_ID] = createEmptyMessageDialogState();
-      }
-    }),
-    clearAllStreaming: create.reducer((state, action2) => {
-      const targetStates = action2.payload?.all ? Object.entries(state.dialogStateById) : [[
-        resolveMessageDialogId(
-          state,
-          action2.payload?.dialogId,
-          action2.payload?.dialogKey
-        ),
-        getMessageDialogState(state, action2.payload?.dialogId, action2.payload?.dialogKey)
-      ]];
-      targetStates.forEach(([dialogId, dialogState]) => {
-        const updates = Object.values(dialogState.msgs.entities).filter((m) => m?.isStreaming).map((m) => ({ id: m.id, changes: { isStreaming: false } }));
-        if (updates.length > 0) {
-          updateManyMessages(dialogState, updates);
-        }
-        setStreamingMessageId(dialogId, null);
-        markMessageSessionAbort(dialogId);
-      });
-    }),
-    removeTransientMessage: create.reducer(
-      (state, action2) => {
-        const payload = typeof action2.payload === "string" ? { id: action2.payload } : action2.payload;
-        const dialogId = payload.dialogId ?? findDialogIdByMessageId(state, payload.id);
-        const dialogState = ensureMessageDialogState(state, dialogId);
-        removeOneMessage(dialogState, payload.id);
-      }
-    ),
-    // Error-path finalizer: keep whatever the transient message already shows
-    // instead of wiping the trace. Decision rules live in messageFinalizeOnError
-    // (Wave15); this reducer applies them + clears the streaming index.
-    finalizeTransientMessageOnError: create.reducer(
-      (state, action2) => {
-        const payload = typeof action2.payload === "string" ? { id: action2.payload } : action2.payload;
-        const dialogId = payload.dialogId ?? findDialogIdByMessageId(state, payload.id);
-        const dialogState = ensureMessageDialogState(state, dialogId);
-        const existing = dialogState.msgs.entities[payload.id];
-        const decision = resolveFinalizeTransientOnError(
-          existing,
-          payload.error
-        );
-        if (decision.kind === "noop") return;
-        if (decision.kind === "remove") {
-          removeOneMessage(dialogState, payload.id);
-          setStreamingMessageId(dialogId, null);
-          return;
-        }
-        updateOneMessage(dialogState, {
-          id: payload.id,
-          changes: decision.changes
-        });
-        setStreamingMessageId(dialogId, null);
-      }
-    ),
-    addToolMessage: create.reducer((state, action2) => {
-      const dialogState = ensureMessageDialogState(
-        state,
-        inferDialogIdFromMessage(action2.payload)
-      );
-      addOneMessage(dialogState, action2.payload);
-    }),
-    updateToolMessage: create.reducer((state, action2) => {
-      const dialogState = ensureMessageDialogState(
-        state,
-        action2.payload.dialogId ?? findDialogIdByMessageId(state, action2.payload.id)
-      );
-      updateOneMessage(dialogState, action2.payload);
-    }),
-    removeMessagesByIds: create.reducer((state, action2) => {
-      const dialogState = ensureMessageDialogState(state, action2.payload.dialogId);
-      dialogState.msgs = messagesAdapter.removeMany(dialogState.msgs, action2.payload.ids);
-    }),
-    setMessages: create.reducer((state, action2) => {
-      const dialogState = ensureMessageDialogState(state, action2.payload.dialogId);
-      if (action2.payload.replace) {
-        setAllMessages(dialogState, action2.payload.messages);
-      } else {
-        upsertManyMessages(dialogState, action2.payload.messages);
-      }
-      if (action2.payload.isLoadingInitial !== void 0) {
-        patchMessageSession(action2.payload.dialogId, {
-          isLoadingInitial: action2.payload.isLoadingInitial
-        });
-      }
-    }),
-    prepareAndPersistMessage: create.asyncThunk(
-      async (args, thunkApi) => {
-        const { message, dialogConfig } = args;
-        const { getState, dispatch, rejectWithValue } = thunkApi;
-        const state = getState();
-        if (!dialogConfig) {
-          return rejectWithValue("Missing dialogConfig");
-        }
-        const dialogKey = dialogConfig.dbKey || dialogConfig.id;
-        const dialogId = extractCustomId(dialogKey);
-        const currentAccountUserId = selectIdentityUserId(state) ?? null;
-        const dialogConfigUserId = dialogConfig.userId;
-        const { fullMessage } = assemblePersistedUserMessage({
-          message,
-          dialogId,
-          dialogKey,
-          currentAccountUserId,
-          dialogConfigUserId: typeof dialogConfigUserId === "string" ? dialogConfigUserId : null
-        });
-        const userId = fullMessage.userId;
-        dispatch(
-          addReferenceKeysAction({
-            content: message.content,
-            dialogKey
-          })
-        ).catch((err) => console.error("Failed to add refs:", err));
-        dispatch(messageActions.addUserMessage({ ...fullMessage, dialogId }));
-        const { controller, ...messageToWrite } = fullMessage;
-        await dispatch(
-          write({
-            data: { ...messageToWrite, type: "msg" /* MSG */ },
-            customKey: fullMessage.dbKey,
-            userId
-          })
-        ).unwrap();
-        return fullMessage;
-      }
-    ),
-    prepareAndPersistUserMessage: create.asyncThunk(
-      async (args, thunkApi) => {
-        const { userInput, dialogConfig } = args;
-        const { dispatch } = thunkApi;
-        return dispatch(
-          messageActions.prepareAndPersistMessage({
-            message: {
-              role: "user",
-              content: userInput
-            },
-            dialogConfig
-          })
-        ).unwrap();
-      }
-    ),
-    /**
-     * 初始化当前对话消息
-     */
-    initMsgs: create.asyncThunk(
-      async ({
-        dialogId,
-        dialogKey,
-        limit,
-        isNew
-      }, thunkApi) => {
-        const { db } = thunkApi.extra;
-        const { getState, signal, dispatch } = thunkApi;
-        const state = getState();
-        const { currentToken: token, remoteServers } = getRuntimeServerContext(state);
-        const { localMessages, remotePromise, earlyReturned } = await fetchAndCacheMessagesLocalFirst({
-          db,
-          dialogId,
-          dialogKey,
-          limit,
-          token,
-          remoteServers,
-          signal
-        });
-        const validLocalMessages = localMessages.filter(isValidMessage);
-        if (earlyReturned) {
-          dispatch(
-            messageActions.setMessages({
-              dialogId,
-              messages: validLocalMessages,
-              isLoadingInitial: false
-            })
-          );
-          remotePromise.then((finalMessages2) => {
-            dispatch(
-              messageActions.setMessages({
-                dialogId,
-                messages: finalMessages2.filter(isValidMessage)
-              })
-            );
-          }).catch((err) => {
-            console.error("[initMsgs] background remote revalidate failed:", err);
-          });
-          return validLocalMessages;
-        }
-        const finalMessages = (await remotePromise).filter(isValidMessage);
-        try {
-          const rootState = getState();
-          const decision = resolveInitMsgsSummaryResume({
-            entities: rootState.db?.entities,
-            dialogId
-          });
-          if (decision.resume) {
-            console.log("[initMsgs] Found suspended summary task, resuming...", decision.dialogKey);
-            thunkApi.dispatch(patch({ dbKey: decision.dialogKey, changes: { summaryPending: false } }));
-            updateDialogSummaryAction(
-              { dialogKey: decision.dialogKey, preFetchedMessages: finalMessages },
-              thunkApi
-            ).catch((err) => console.error("Resume summary failed:", err));
-          }
-        } catch {
-          console.error("[initMsgs] Failed to resume summary");
-        }
-        return finalMessages;
-      },
-      {
-        pending: (state, action2) => {
-          const { dialogId, isNew, limit } = action2.meta.arg;
-          const dialogState = ensureMessageDialogState(state, dialogId);
-          if (isNew) {
-            if (Object.keys(dialogState.msgs.entities).length === 0) {
-              removeAllMessages(dialogState);
-            }
-          }
-          ensureMessageSession(dialogId);
-          setActiveMessageDialogId(dialogId);
-          patchMessageSession(dialogId, {
-            firstStreamProcessed: false,
-            isLoadingInitial: true,
-            isLoadingOlder: false,
-            // Full-history init: no older page. Partial limit still allows load-older.
-            hasMoreOlder: typeof limit === "number" && Number.isFinite(limit) && limit > 0,
-            error: null,
-            lastStreamTimestamp: 0,
-            currentInitMsgsRequestId: action2.meta.requestId
-          });
-        },
-        fulfilled: (state, action2) => {
-          const dialogId = action2.meta.arg.dialogId;
-          const dialogState = ensureMessageDialogState(state, dialogId);
-          const session = getMessageSession(dialogId);
-          if (session.currentInitMsgsRequestId !== action2.meta.requestId) {
-            return;
-          }
-          const limit = action2.meta.arg.limit;
-          patchMessageSession(dialogId, {
-            currentInitMsgsRequestId: void 0,
-            isLoadingInitial: false,
-            hasMoreOlder: resolveInitMsgsHasMoreOlder({
-              limit,
-              fetchedCount: action2.payload.length
-            })
-          });
-          const hasLocalStreaming = getHasStreamingMessage(dialogId) || Object.values(dialogState.msgs.entities).some(
-            (message) => message?.isStreaming
-          );
-          const writeMode = resolveInitMsgsFulfilledWriteMode({
-            isNew: action2.meta.arg.isNew,
-            hasLocalStreaming
-          });
-          if (writeMode === "upsert") {
-            upsertManyMessages(dialogState, action2.payload);
-          } else {
-            setAllMessages(dialogState, action2.payload);
-          }
-        },
-        rejected: (state, action2) => {
-          const dialogId = action2.meta.arg.dialogId;
-          ensureMessageDialogState(state, dialogId);
-          const session = getMessageSession(dialogId);
-          if (session.currentInitMsgsRequestId !== action2.meta.requestId) {
-            return;
-          }
-          if (action2.meta?.aborted) {
-            patchMessageSession(dialogId, {
-              currentInitMsgsRequestId: void 0,
-              isLoadingInitial: false
-            });
-            return;
-          }
-          patchMessageSession(dialogId, {
-            currentInitMsgsRequestId: void 0,
-            isLoadingInitial: false,
-            error: action2.error instanceof Error ? action2.error : new Error(String(action2.error))
-          });
-          console.error(`${action2.type} failed:`, action2.error);
-        }
-      }
-    ),
-    /**
-     * 加载更早的历史消息
-     */
-    loadOlderMessages: create.asyncThunk(
-      async ({
-        dialogId,
-        dialogKey,
-        beforeKey,
-        limit = OLDER_LOAD_LIMIT
-      }, thunkApi) => {
-        const { getState, extra, signal } = thunkApi;
-        const { db } = extra;
-        const state = getState();
-        const { currentToken: token, remoteServers } = getRuntimeServerContext(state);
-        const messages = (await fetchAndCacheMessages({
-          db,
-          dialogId,
-          dialogKey,
-          limit,
-          beforeKey,
-          token,
-          remoteServers,
-          signal
-        })).filter(isValidMessage);
-        return { messages, limit };
-      },
-      {
-        pending: (state, action2) => {
-          const dialogId = action2.meta.arg.dialogId;
-          ensureMessageDialogState(state, dialogId);
-          patchMessageSession(dialogId, {
-            isLoadingOlder: true,
-            error: null,
-            currentLoadOlderRequestId: action2.meta.requestId
-          });
-        },
-        fulfilled: (state, action2) => {
-          const dialogId = action2.meta.arg.dialogId;
-          const dialogState = ensureMessageDialogState(state, dialogId);
-          const session = getMessageSession(dialogId);
-          if (session.currentLoadOlderRequestId !== action2.meta.requestId) {
-            return;
-          }
-          const { messages, limit } = action2.payload;
-          patchMessageSession(dialogId, {
-            isLoadingOlder: false,
-            currentLoadOlderRequestId: void 0,
-            ...messages.length < limit ? { hasMoreOlder: false } : {}
-          });
-          if (messages.length > 0) {
-            upsertManyMessages(dialogState, messages);
-          }
-        },
-        rejected: (state, action2) => {
-          const dialogId = action2.meta.arg.dialogId;
-          ensureMessageDialogState(state, dialogId);
-          const session = getMessageSession(dialogId);
-          if (session.currentLoadOlderRequestId !== action2.meta.requestId) {
-            return;
-          }
-          if (action2.meta?.aborted) {
-            patchMessageSession(dialogId, {
-              isLoadingOlder: false,
-              currentLoadOlderRequestId: void 0
-            });
-            return;
-          }
-          patchMessageSession(dialogId, {
-            isLoadingOlder: false,
-            currentLoadOlderRequestId: void 0,
-            error: action2.error instanceof Error ? action2.error : new Error(String(action2.error))
-          });
-          console.error(`${action2.type} failed:`, action2.error);
-        }
-      }
-    ),
-    /**
-     * 一条流式回复结束
-     */
-    messageStreamEnd: create.asyncThunk(
-      async (payload, { dispatch, getState }) => {
-        const {
-          finalContentBuffer,
-          totalUsage,
-          billingUsageRecords,
-          msgKey,
-          agentConfig,
-          dialogId,
-          dialogKey,
-          messageId,
-          reasoningBuffer,
-          toolCalls,
-          finishReason,
-          billingFailed,
-          skipBilling
-        } = payload;
-        const spaceId = payload.spaceId;
-        const rawAgentName = asTrimmedString(agentConfig?.name);
-        const normalizedContentBuffer = await normalizeAssistantContentBuffer(
-          finalContentBuffer,
-          dialogId,
-          messageId,
-          dispatch,
-          getState,
-          spaceId ? { spaceId, agentName: rawAgentName || void 0 } : void 0
-        );
-        const {
-          thinkContent,
-          textContent,
-          visibleContent: finalVisibleContent
-        } = finalizeAssistantMessageContent(
-          normalizedContentBuffer,
-          reasoningBuffer
-        );
-        const {
-          billedUsage,
-          billedEstimatedUsage,
-          hasReportedUsage,
-          titleEligible
-        } = resolveStreamEndBillingUsages({
-          agentConfig,
-          totalUsage,
-          finalVisibleContent
-        });
-        const {
-          finalUsageData,
-          agentName,
-          persistedMetadata,
-          otherPersistedMessageMetadata
-        } = prepareStreamEndPersistInputs({
-          totalUsage,
-          agentConfig,
-          messageMetadata: payload.messageMetadata
-        });
-        const { finalMetadata } = resolveStreamEndFinalMetadata({
-          persistedMetadata,
-          toolCalls,
-          messages: selectAllMsgs(getState(), dialogId),
-          finalContent: finalVisibleContent
-        });
-        const state = getState();
-        const dialogConfig = selectById(state, dialogKey);
-        const dialogConfigUserId = dialogConfig?.userId;
-        const currentAccountUserId = selectIdentityUserId(state) ?? null;
-        const userId = resolveMessageOwner({
-          dialogConfigUserId: typeof dialogConfigUserId === "string" ? dialogConfigUserId : null,
-          dialogKey,
-          currentAccountUserId
-        });
-        const finalMessage = assembleFinalAssistantMessage({
-          messageId,
-          msgKey,
-          finalVisibleContent,
-          thinkContent,
-          agentConfig,
-          finalUsageData,
-          toolCalls,
-          finishReason,
-          otherPersistedMessageMetadata,
-          finalMetadata,
-          agentName,
-          // Authoritative owner last so metadata cannot overwrite it.
-          userId
-        });
-        const { controller, ...messageToWrite } = finalMessage;
-        await dispatch(
-          write({
-            data: { ...messageToWrite, type: "msg" /* MSG */ },
-            customKey: msgKey,
-            userId
-          })
-        ).unwrap();
-        const {
-          billingMode,
-          updateTitle,
-          updateSummary,
-          summaryForce,
-          summaryReason,
-          addRefs
-        } = resolveStreamEndPostWritePolicy({
-          hasReportedUsage,
-          billingFailed,
-          skipBilling,
-          agentProvider: agentConfig?.provider,
-          titleEligible,
-          textContent,
-          toolCalls
-        });
-        await dispatchStreamEndBilling({
-          dispatch,
-          updateTokensAction: updateTokens,
-          billingMode,
-          billingUsageRecords,
-          billedUsage,
-          billedEstimatedUsage,
-          dialogId,
-          dialogKey,
-          agentConfig
-        });
-        if (updateTitle) {
-          dispatch(updateDialogTitle({ dialogKey, agentConfig }));
-        }
-        if (updateSummary) {
-          const messagesForSummary = [
-            ...selectAllMsgs(getState(), dialogId),
-            finalMessage
-          ];
-          updateDialogSummaryAction(
-            {
-              dialogKey,
-              preFetchedMessages: messagesForSummary,
-              force: summaryForce,
-              reason: summaryReason
-            },
-            { dispatch, getState }
-          ).catch((err) => console.error("Summary update failed:", err));
-          if (addRefs) {
-            dispatch(addReferenceKeysAction({
-              content: finalVisibleContent,
-              dialogKey
-            })).catch((err) => console.error("Failed to add assistant refs:", err));
-          }
-        }
-        captureUnderstandingFromCompletedUiTurn2({
-          state: getState(),
-          agentKey: agentConfig?.dbKey,
-          dialogId,
-          dialogKey,
-          spaceId: payload.spaceId,
-          assistantText: textContent,
-          toolCalls
-        }).catch(
-          (err) => console.error("Understanding memory capture failed:", err)
-        );
-        return {
-          id: messageId,
-          dbKey: msgKey,
-          role: "assistant",
-          content: finalMessage.content,
-          thinkContent: finalMessage.thinkContent,
-          usage: finalMessage.usage,
-          agentKey: finalMessage.agentKey,
-          cybotKey: finalMessage.cybotKey,
-          tool_calls: finalMessage.tool_calls,
-          dialogId,
-          agentName: finalMessage.agentName
-        };
-      },
-      {
-        fulfilled: (state, action2) => {
-          const payload = action2.payload;
-          const dialogState = ensureMessageDialogState(state, payload.dialogId);
-          const existing = dialogState.msgs.entities[payload.id];
-          upsertOneMessage(dialogState, {
-            ...existing ?? {},
-            ...payload,
-            role: payload.role ?? existing?.role ?? "assistant",
-            dbKey: payload.dbKey ?? existing?.dbKey ?? action2.meta.arg.msgKey,
-            isStreaming: false,
-            imageGenerationState: void 0
-          });
-          setStreamingMessageId(payload.dialogId, null);
-        },
-        rejected: (state, action2) => {
-          const arg = action2.meta?.arg;
-          const messageId = arg?.messageId;
-          const dialogId = arg?.dialogId;
-          console.error("messageStreamEnd failed:", action2.error);
-          if (messageId && dialogId) {
-            const dialogState = ensureMessageDialogState(state, dialogId);
-            updateOneMessage(dialogState, {
-              id: messageId,
-              changes: {
-                isStreaming: false,
-                imageGenerationState: void 0,
-                content: appendSaveFailureToContent(
-                  dialogState.msgs.entities[messageId]?.content
-                )
-              }
-            });
-          }
-          if (dialogId) {
-            setStreamingMessageId(dialogId, null);
-          }
-        }
-      }
-    ),
-    deleteMessage: create.asyncThunk(
-      async (dbKey, { dispatch, getState }) => {
-        const state = getState();
-        const dialogId = findDialogIdByMessageDbKey(state.message, dbKey);
-        const dialogState = dialogId ? state.message.dialogStateById[dialogId] : void 0;
-        const entities = dialogState?.msgs.entities ?? {};
-        const msg = Object.values(entities).find((m) => m?.dbKey === dbKey);
-        const { id: msgId, extraRemoveId, extraRemoveDbKey } = planDeleteMessageCascade(msg, entities);
-        await dispatch(remove(dbKey));
-        if (extraRemoveDbKey) {
-          await dispatch(remove(extraRemoveDbKey));
-        }
-        return { id: msgId, extraRemoveId, dialogId };
-      },
-      {
-        fulfilled: (state, action2) => {
-          const { id, extraRemoveId, dialogId } = action2.payload;
-          const dialogState = ensureMessageDialogState(state, dialogId);
-          if (id) {
-            removeOneMessage(dialogState, id);
-          }
-          if (extraRemoveId) {
-            removeOneMessage(dialogState, extraRemoveId);
-          }
-        }
-      }
-    ),
-    editUserMessageAndReplay: create.asyncThunk(
-      async (args, thunkApi) => {
-        const { dispatch, getState, rejectWithValue } = thunkApi;
-        try {
-          const state = getState();
-          const dialogKey = args.dialogKey ?? selectCurrentDialogKey(state);
-          if (!dialogKey) {
-            throw new Error("editUserMessageAndReplay: dialogKey is required.");
-          }
-          const dialogConfig = selectById(state, dialogKey);
-          if (!dialogConfig) {
-            throw new Error("editUserMessageAndReplay: dialog config is missing.");
-          }
-          const dialogId = dialogConfig.id ?? extractCustomId(dialogKey);
-          const messages = selectAllMsgs(state, dialogId);
-          const plan = planEditUserMessageAndReplay({
-            messages,
-            messageId: args.messageId,
-            originalContent: args.originalContent,
-            nextText: args.nextText
-          });
-          if (!plan.ok) {
-            throw new Error(plan.message);
-          }
-          const { targetMessage, nextContent, trailingMessages } = plan;
-          dispatch(
-            messageActions.updateToolMessage({
-              id: targetMessage.id,
-              dialogId,
-              changes: {
-                content: nextContent
-              }
-            })
-          );
-          if (trailingMessages.length > 0) {
-            dispatch(
-              messageActions.removeMessagesByIds({
-                dialogId,
-                ids: trailingMessages.map((message) => message.id)
-              })
-            );
-          }
-          await dispatch(
-            patch({
-              dbKey: targetMessage.dbKey,
-              changes: {
-                content: nextContent
-              }
-            })
-          ).unwrap();
-          await dispatch(
-            patch({
-              dbKey: dialogKey,
-              changes: {
-                summary: null,
-                summarizedBeforeId: null
-              }
-            })
-          ).unwrap();
-          await Promise.all(
-            trailingMessages.map(
-              (m) => m?.dbKey ? dispatch(remove(m.dbKey)).unwrap() : Promise.resolve()
-            )
-          );
-          const { agentKeyToUse, agentConfigToUse, effectiveRuntimeOptions } = resolveHandleSendMessageContext({
-            dialogConfig,
-            targetAgentKey: args.targetAgentKey,
-            runtimeOptions: args.runtimeOptions
-          });
-          if (agentKeyToUse) {
-            const { streamAgentChatTurn } = await import("./agentSlice-UP66DIC2.js");
-            await dispatch(
-              streamAgentChatTurn({
-                agentKey: agentKeyToUse,
-                ...agentConfigToUse ? { agentConfig: agentConfigToUse } : {},
-                userInput: nextContent,
-                dialogKey,
-                parentMessageId: void 0,
-                runtimeOptions: effectiveRuntimeOptions,
-                quickChatPerfStartedAt: args.quickChatPerfStartedAt
-              })
-            ).unwrap();
-          }
-          return {
-            editedMessageId: targetMessage.id,
-            removedMessageIds: trailingMessages.map((message) => message.id)
-          };
-        } catch (error) {
-          return rejectWithValue(toErrorMessage(error));
-        }
-      }
-    )
-  }),
-  selectors: {}
-});
-messageActions = messageSlice.actions;
-var dialogMessageSelectors = messagesAdapter.getSelectors(
-  (dialogState) => dialogState.msgs
-);
-var selectMessageDialogState = (state, dialogId) => getMessageDialogState(state.message, dialogId);
-var selectAllMsgs = createSelector(
-  [
-    (state, dialogId) => selectMessageDialogState(state, dialogId)
-  ],
-  (dialogState) => dialogMessageSelectors.selectAll(dialogState)
-);
-var selectMsgById = (state, messageId, dialogId) => dialogMessageSelectors.selectById(
-  getMessageDialogState(state.message, dialogId),
-  messageId
-);
-var {
-  addUserMessage,
-  messageStreaming,
-  setMessages,
-  resetMsgs,
-  clearAllStreaming,
-  removeTransientMessage,
-  finalizeTransientMessageOnError,
-  prepareAndPersistMessage,
-  prepareAndPersistUserMessage,
-  initMsgs,
-  loadOlderMessages,
-  messageStreamEnd,
-  deleteMessage,
-  editUserMessageAndReplay,
-  addToolMessage,
-  updateToolMessage,
-  removeMessagesByIds
-} = messageSlice.actions;
-var messageSlice_default = messageSlice.reducer;
-
-// packages/chat/dialog/actions/updateTokensAction.ts
-var import_date_fns = __toESM(require_date_fns());
-import { ulid } from "ulid";
-
-// packages/render/web/ui/toastStore.ts
-var EXIT_MS = 320;
-var raf = typeof globalThis.requestAnimationFrame === "function" ? (cb) => globalThis.requestAnimationFrame(cb) : (cb) => {
-  setTimeout(cb, 16);
-};
-var ToastStore = class {
-  toasts = [];
-  listeners = /* @__PURE__ */ new Set();
-  nextId = 0;
-  subscribe = (listener) => {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  };
-  getSnapshot = () => this.toasts;
-  add(item) {
-    const id = item.id ?? `toast-${++this.nextId}`;
-    const filtered = this.toasts.filter((t) => t.id !== id);
-    const entry = { ...item, id, phase: "entering" };
-    this.toasts = [...filtered, entry];
-    this.notify();
-    raf(
-      () => raf(() => {
-        this.toasts = this.toasts.map(
-          (t) => t.id === id ? { ...t, phase: "visible" } : t
-        );
-        this.notify();
-      })
-    );
-    if (item.timeout && item.timeout > 0) {
-      setTimeout(() => this.close(id), item.timeout);
-    }
-    return id;
-  }
-  close(id) {
-    if (id) {
-      if (!this.toasts.some((t) => t.id === id)) return;
-      this.toasts = this.toasts.map(
-        (t) => t.id === id ? { ...t, phase: "exiting" } : t
-      );
-    } else {
-      this.toasts = this.toasts.map((t) => ({ ...t, phase: "exiting" }));
-    }
-    this.notify();
-    setTimeout(() => {
-      this.toasts = id ? this.toasts.filter((t) => t.id !== id) : [];
-      this.notify();
-    }, EXIT_MS);
-  }
-  notify = () => {
-    this.listeners.forEach((fn) => fn());
-  };
-};
-var toastManager = new ToastStore();
-
-// packages/app/utils/toast.ts
-var DEFAULT_TIMEOUT = 4e3;
-function add(message, type, options) {
-  const timeout = options?.timeout ?? options?.duration;
-  return toastManager.add({
-    id: options?.id,
-    title: message,
-    type,
-    icon: options?.icon,
-    description: options?.description,
-    action: options?.action,
-    position: options?.position,
-    // loading toasts stay until explicitly replaced/closed (timeout=0)
-    timeout: type === "loading" ? timeout ?? 0 : timeout ?? DEFAULT_TIMEOUT
-  });
-}
-var toast = Object.assign(
-  (message, options) => add(message, "default", options),
-  {
-    success: (message, options) => add(message, "success", options),
-    error: (message, options) => add(message, "error", options),
-    info: (message, options) => add(message, "default", options),
-    loading: (message, options) => add(message, "loading", options),
-    dismiss: (id) => toastManager.close(id)
-  }
-);
-
-// packages/ai/token/saveTokenRecord.ts
-var logger = createClientLogger("token-record");
-var createTokenRecord = (data, { cost, inputPrice, outputPrice } = {}) => ({
-  ...data,
-  cost: cost || data.cost,
-  inputPrice,
-  outputPrice
-});
-var saveTokenRecord = async (tokenData, record, thunkApi, callId) => {
-  const ownerUserId = tokenData.userId || record.userId;
-  const eventTime = tokenData.timestamp ?? record.createdAt ?? Date.now();
-  const key = callId ? createTokenKey.recordForStableCall(ownerUserId, callId) : createTokenKey.record(ownerUserId, eventTime);
-  try {
-    await thunkApi.dispatch(
-      write({
-        data: { ...record, id: key, type: "token" /* TOKEN */, userId: ownerUserId },
-        customKey: key,
-        userId: ownerUserId
-      })
-    ).unwrap();
-  } catch (error) {
-    logger.error(
-      {
-        key,
-        userId: tokenData.userId,
-        error: toErrorMessage(error)
-      },
-      "Failed to save token record"
-    );
-    toast.error("Failed to save token record");
-    throw error;
-  }
-};
-
-// packages/ai/token/calculatePrice.ts
-var sanitizeCost = (raw) => {
-  const rounded = Number(raw.toFixed(6));
-  return Number.isFinite(rounded) && rounded > 0 ? rounded : 0;
-};
-var resolveModelPrice = (model, usage) => {
-  let activePrice = { ...model.price };
-  if (model.pricingStrategy?.type === "tiered_context") {
-    const contextSize = usage.input_tokens || 0;
-    const tiers = model.pricingStrategy.tiers || [];
-    const sortedTiers = [...tiers].sort((a, b) => a.minContext - b.minContext);
-    for (const tier of sortedTiers) {
-      if (contextSize >= tier.minContext) {
-        activePrice = { ...tier.price };
-      }
-    }
-  }
-  return activePrice;
-};
-var scaleModelInputOutputPrice = (price, multiplier) => ({
-  ...price,
-  input: price.input * multiplier,
-  output: price.output * multiplier
-});
-var scaleModelServiceTierPrice = (price, inputOutputMultiplier, cacheMultiplier) => ({
-  ...price,
-  input: price.input * inputOutputMultiplier,
-  output: price.output * inputOutputMultiplier,
-  ...typeof cacheMultiplier === "number" && typeof price.cachingWrite === "number" ? { cachingWrite: price.cachingWrite * cacheMultiplier } : {},
-  ...typeof cacheMultiplier === "number" && typeof price.cachingRead === "number" ? { cachingRead: price.cachingRead * cacheMultiplier } : {}
-});
-var resolveGoogleServiceTierPrice = (model, price, billingServiceTier) => {
-  const normalizedTier = asTrimmedLowercaseString(billingServiceTier);
-  const imageOutputPrice = typeof model.imageTokenPricePerMillion === "number" ? model.imageTokenPricePerMillion : void 0;
-  const priceWithImageOutput = typeof imageOutputPrice === "number" ? { ...price, output: imageOutputPrice } : price;
-  const serviceTierMultiplier = normalizedTier === "batch" || normalizedTier === "flex" || normalizedTier === "priority" ? model.serviceTierPriceMultipliers?.[normalizedTier] : void 0;
-  if (serviceTierMultiplier) {
-    return scaleModelServiceTierPrice(
-      priceWithImageOutput,
-      serviceTierMultiplier.inputOutput,
-      serviceTierMultiplier.cache
-    );
-  }
-  if (normalizedTier === "flex" || normalizedTier === "batch") {
-    return scaleModelInputOutputPrice(priceWithImageOutput, 0.5);
-  }
-  if (normalizedTier === "priority") {
-    return scaleModelInputOutputPrice(priceWithImageOutput, 1.8);
-  }
-  return priceWithImageOutput;
-};
-var resolveEffectiveModelPrice = ({
-  model,
-  usage,
-  provider,
-  billingServiceTier,
-  nowMs
-}) => {
-  const resolvedPrice = resolveModelPrice(model, usage);
-  if ((provider === "nolo" || provider === "deepseek") && isPlatformHostedDeepSeekV4Model(model.name)) {
-    return getPlatformHostedDeepSeekV4Price(model.name, nowMs);
-  }
-  if (provider === "google") {
-    return resolveGoogleServiceTierPrice(model, resolvedPrice, billingServiceTier);
-  }
-  if (provider === "runinfra" || provider === "baseten") {
-    return resolvedPrice;
-  }
-  return resolvedPrice;
-};
-var getEffectivePrices = (resolvedPrice, externalPrice) => {
-  const effectiveInputPrice = Math.max(
-    externalPrice?.input || 0,
-    resolvedPrice.input
-  );
-  const effectiveOutputPrice = Math.max(
-    externalPrice?.output || 0,
-    resolvedPrice.output
-  );
-  return {
-    input: effectiveInputPrice,
-    output: effectiveOutputPrice,
-    cachingWrite: resolvedPrice.cachingWrite || 0,
-    cachingRead: resolvedPrice.cachingRead || 0
-  };
-};
-var calculateAnthropicCost = (resolvedPrice, usage, externalPrice) => {
-  const {
-    input_tokens,
-    output_tokens,
-    cache_creation_input_tokens,
-    cache_read_input_tokens
-  } = usage;
-  const {
-    input: effectiveInputPrice,
-    output: effectiveOutputPrice,
-    cachingWrite: effectiveCachingWritePrice,
-    cachingRead: effectiveCachingReadPrice
-  } = getEffectivePrices(resolvedPrice, externalPrice);
-  const regularInputTokens = input_tokens - cache_read_input_tokens;
-  const regularTotal = (regularInputTokens * resolvedPrice.input + output_tokens * resolvedPrice.output + cache_creation_input_tokens * (resolvedPrice.cachingWrite || 0) + cache_read_input_tokens * (resolvedPrice.cachingRead || 0)) / 1e6;
-  const chargeTotal = (regularInputTokens * effectiveInputPrice + output_tokens * effectiveOutputPrice + cache_creation_input_tokens * effectiveCachingWritePrice + cache_read_input_tokens * effectiveCachingReadPrice) / 1e6;
-  return {
-    regular: regularTotal,
-    charge: chargeTotal,
-    details: {
-      inputCost: regularInputTokens * resolvedPrice.input / 1e6,
-      outputCost: output_tokens * resolvedPrice.output / 1e6,
-      cachingWriteCost: cache_creation_input_tokens * (resolvedPrice.cachingWrite || 0) / 1e6,
-      cachingReadCost: cache_read_input_tokens * (resolvedPrice.cachingRead || 0) / 1e6
-    }
-  };
-};
-var calculateCacheBasedCost = (resolvedPrice, usage, externalPrice) => {
-  const { input_tokens, output_tokens, cache_read_input_tokens } = usage;
-  const { input: effectiveInputPrice, output: effectiveOutputPrice } = getEffectivePrices(resolvedPrice, externalPrice);
-  const inputTokens = Math.max(0, input_tokens ?? 0);
-  const cacheRead = Math.min(
-    Math.max(0, cache_read_input_tokens ?? 0),
-    inputTokens
-  );
-  const outputTokens = Math.max(0, output_tokens ?? 0);
-  const cacheMissTokens = inputTokens - cacheRead;
-  const cacheHitPrice = resolvedPrice.inputCacheHit || 0;
-  const regularTotal = (cacheMissTokens * resolvedPrice.input + cacheRead * cacheHitPrice + outputTokens * resolvedPrice.output) / 1e6;
-  const chargeTotal = (cacheMissTokens * effectiveInputPrice + cacheRead * cacheHitPrice + outputTokens * effectiveOutputPrice) / 1e6;
-  return {
-    regular: regularTotal,
-    charge: chargeTotal,
-    details: {
-      inputCost: cacheMissTokens * resolvedPrice.input / 1e6,
-      outputCost: outputTokens * resolvedPrice.output / 1e6,
-      cachingReadCost: cacheRead * cacheHitPrice / 1e6,
-      cachingWriteCost: 0
-    }
-  };
-};
-var calculateSimpleCost = (resolvedPrice, usage, externalPrice) => {
-  const { input_tokens, output_tokens } = usage;
-  const { input: effectiveInputPrice, output: effectiveOutputPrice } = getEffectivePrices(resolvedPrice, externalPrice);
-  const regularTotal = (input_tokens * resolvedPrice.input + output_tokens * resolvedPrice.output) / 1e6;
-  const chargeTotal = (input_tokens * effectiveInputPrice + output_tokens * effectiveOutputPrice) / 1e6;
-  return {
-    regular: regularTotal,
-    charge: chargeTotal,
-    details: {
-      inputCost: input_tokens * resolvedPrice.input / 1e6,
-      outputCost: output_tokens * resolvedPrice.output / 1e6,
-      cachingWriteCost: 0,
-      cachingReadCost: 0
-    }
-  };
-};
-var calculateOpenRouterFallbackCost = (resolvedPrice, usage, externalPrice) => {
-  if (typeof resolvedPrice.cachingWrite === "number" || typeof resolvedPrice.cachingRead === "number") {
-    return calculateAnthropicCost(resolvedPrice, usage, externalPrice);
-  }
-  if (typeof resolvedPrice.inputCacheHit === "number") {
-    return calculateCacheBasedCost(resolvedPrice, usage, externalPrice);
-  }
-  return calculateSimpleCost(resolvedPrice, usage, externalPrice);
-};
-var API_REPORTED_COST_MULTIPLIER = 8;
-var zeroCostBreakdown = () => ({
-  regular: 0,
-  charge: 0,
-  details: {
-    inputCost: 0,
-    outputCost: 0,
-    cachingWriteCost: 0,
-    cachingReadCost: 0
-  }
-});
-var calculateApiReportedCost = (usage) => {
-  if (!usage || typeof usage.cost !== "number" || usage.cost <= 0) {
-    return zeroCostBreakdown();
-  }
-  const regular = usage.cost * API_REPORTED_COST_MULTIPLIER;
-  return {
-    regular,
-    charge: regular,
-    details: {
-      inputCost: regular,
-      outputCost: 0,
-      cachingWriteCost: 0,
-      cachingReadCost: 0
-    }
-  };
-};
-var resolveOpenAIBuiltInImageSurcharge = (model, usage) => {
-  const imageGenerationCount = asOptionalFiniteNumber(usage.image_generation_count) ?? 0;
-  const pricePerImage = getApproxPricePerImage(model) ?? // gpt-image-2 已收进 nolo 平台托管目录（provider=nolo）
-  getApproxPricePerImage(findModelConfig("nolo", "gpt-image-2")) ?? 0;
-  if (imageGenerationCount <= 0 || pricePerImage <= 0) return 0;
-  return imageGenerationCount * pricePerImage;
-};
-var calculateBasicCost = (model, usage, provider, externalPrice, billingServiceTier, nowMs) => {
-  if (!usage || typeof usage.input_tokens !== "number") {
-    throw new Error("Invalid usage data");
-  }
-  const resolvedPrice = resolveEffectiveModelPrice({
-    model,
-    usage,
-    provider,
-    billingServiceTier,
-    nowMs
-  });
-  switch (provider) {
-    case "deepseek":
-    case "openai":
-    case "deepinfra":
-    case "runinfra":
-    case "baseten":
-      return calculateCacheBasedCost(resolvedPrice, usage, externalPrice);
-    // without it keep simple full-price billing so cached tokens are not
-    // priced at 0 — but a platform-hosted model用于 agentic 循环时必须补上
-    // 这一项，否则每轮重放的上下文会被按 input 原价重复计费。
-    case "nolo":
-    case "upstream-k3":
-      return typeof resolvedPrice.inputCacheHit === "number" ? calculateCacheBasedCost(resolvedPrice, usage, externalPrice) : calculateSimpleCost(resolvedPrice, usage, externalPrice);
-    case "anthropic":
-      return calculateAnthropicCost(resolvedPrice, usage, externalPrice);
-    case "google":
-      if (model.name.includes("gemini-3")) {
-        return calculateAnthropicCost(resolvedPrice, usage, externalPrice);
-      }
-      return calculateSimpleCost(resolvedPrice, usage, externalPrice);
-    case "openrouter": {
-      const reported = calculateApiReportedCost(usage);
-      if (reported.regular > 0) return reported;
-      return calculateOpenRouterFallbackCost(
-        resolvedPrice,
-        usage,
-        externalPrice
-      );
-    }
-    case "xai": {
-      const reported = calculateApiReportedCost(usage);
-      if (reported.regular > 0) return reported;
-      return calculateSimpleCost(resolvedPrice, usage, externalPrice);
-    }
-    case "mistral":
-    case "fireworks":
-    default:
-      return calculateSimpleCost(resolvedPrice, usage, externalPrice);
-  }
-};
-var calculatePayDistribution = (costs, externalPrice, sharingLevel = "default") => {
-  const pay = {};
-  pay[nolotusId] = costs.regular;
-  const sharingRatios = {
-    default: 0,
-    split: 0.5,
-    full: 1
-  };
-  if (externalPrice?.creatorId) {
-    const profit = Math.max(0, costs.charge - costs.regular);
-    if (profit > 0) {
-      switch (sharingLevel) {
-        case "split":
-          pay[externalPrice.creatorId] = profit * sharingRatios.split;
-          break;
-        case "full":
-          pay[externalPrice.creatorId] = profit;
-          break;
-        default:
-          break;
-      }
-    }
-  }
-  return Object.fromEntries(
-    Object.entries(pay).map(([key, value]) => [
-      key,
-      Number(value.toFixed(6))
-    ])
-  );
-};
-var calculatePrice = ({
-  modelName,
-  usage,
-  externalPrice,
-  // 不设默认值，undefined 表示 custom/未知 provider，走 zeroCostModel 路径
-  provider,
-  billingServiceTier,
-  nowMs,
-  sharingLevel = "default"
-}) => {
-  let model;
-  try {
-    model = getModelConfig(provider, modelName);
-  } catch {
-    if (provider === "baseten" && /^(?:zai-org\/)?glm-5[.-]3-flash$/i.test(modelName)) {
-      const costs3 = calculateBasicCost(
-        { name: modelName, hasVision: true, price: PLATFORM_HOSTED_GLM_53_FLASH_BASETEN_PRICE },
-        usage,
-        "baseten",
-        externalPrice,
-        billingServiceTier,
-        nowMs
-      );
-      const pay3 = calculatePayDistribution(costs3, externalPrice, sharingLevel);
-      return { cost: sanitizeCost(costs3.charge), pay: pay3 };
-    }
-    if (isPlatformHostedImageModel(modelName)) {
-      const hostedImageModel = getModelConfig("nolo", modelName);
-      const costs3 = calculateBasicCost(
-        hostedImageModel,
-        usage,
-        provider ?? "nolo",
-        externalPrice,
-        billingServiceTier,
-        nowMs
-      );
-      const surcharge = isPlatformHostedOpenAIImageModel(modelName) ? resolveOpenAIBuiltInImageSurcharge(hostedImageModel, usage) : 0;
-      const adjusted = surcharge > 0 ? {
-        ...costs3,
-        regular: costs3.regular + surcharge,
-        charge: costs3.charge + surcharge
-      } : costs3;
-      const pay3 = calculatePayDistribution(adjusted, externalPrice, sharingLevel);
-      return { cost: sanitizeCost(adjusted.charge), pay: pay3 };
-    }
-    if ((provider === "nolo" || provider === "deepseek") && isPlatformHostedDeepSeekV4Model(modelName)) {
-      const hostedModel = getModelConfig(
-        "nolo",
-        asTrimmedLowercaseString(modelName) === PLATFORM_HOSTED_DEEPSEEK_PRO_MODEL ? PLATFORM_HOSTED_DEEPSEEK_PRO_MODEL : PLATFORM_HOSTED_DEEPSEEK_FLASH_MODEL
-      );
-      const costs3 = calculateBasicCost(
-        hostedModel,
-        usage,
-        provider,
-        externalPrice,
-        billingServiceTier,
-        nowMs
-      );
-      const pay3 = calculatePayDistribution(costs3, externalPrice, sharingLevel);
-      return { cost: sanitizeCost(costs3.charge), pay: pay3 };
-    }
-    if (provider === "nolo" && isPlatformHostedClaudeModel(modelName)) {
-      const compatModel = getModelConfig("nolo", PLATFORM_HOSTED_GLM_53_FLASH_MODEL);
-      const costs3 = calculateBasicCost(
-        compatModel,
-        usage,
-        provider,
-        externalPrice,
-        billingServiceTier,
-        nowMs
-      );
-      const pay3 = calculatePayDistribution(costs3, externalPrice, sharingLevel);
-      return { cost: sanitizeCost(costs3.charge), pay: pay3 };
-    }
-    const zeroCostModel = {
-      name: modelName,
-      hasVision: false,
-      price: { input: 0, output: 0 }
-    };
-    const costs2 = calculateBasicCost(
-      zeroCostModel,
-      usage,
-      "custom",
-      externalPrice,
-      billingServiceTier,
-      nowMs
-    );
-    const pay2 = calculatePayDistribution(costs2, externalPrice, sharingLevel);
-    return { cost: sanitizeCost(costs2.charge), pay: pay2 };
-  }
-  const costs = calculateBasicCost(
-    model,
-    usage,
-    provider || "custom",
-    externalPrice,
-    billingServiceTier,
-    nowMs
-  );
-  const openAIImageSurcharge = provider === "openai" ? resolveOpenAIBuiltInImageSurcharge(model, usage) : 0;
-  const adjustedCosts = openAIImageSurcharge > 0 ? {
-    ...costs,
-    regular: costs.regular + openAIImageSurcharge,
-    charge: costs.charge + openAIImageSurcharge,
-    details: costs.details ? {
-      ...costs.details,
-      outputCost: costs.details.outputCost + openAIImageSurcharge
-    } : costs.details
-  } : costs;
-  const pay = calculatePayDistribution(adjustedCosts, externalPrice, sharingLevel);
-  return {
-    cost: sanitizeCost(adjustedCosts.charge),
-    pay
-  };
-};
-
-// packages/ai/token/normalizeUsage.ts
-var normalizeStringArray = (value) => {
-  if (!Array.isArray(value)) return void 0;
-  const normalized = [...new Set(asTrimmedNonEmptyStringArray(value))];
-  return normalized.length > 0 ? normalized : void 0;
-};
-var finiteTokenCount = (value) => {
-  const finite = asOptionalFiniteNumber(value);
-  if (finite === void 0) return void 0;
-  return Math.max(0, Math.floor(finite));
-};
-var readFiniteNumberField = (usage, field) => {
-  if (!usage || typeof usage !== "object") return void 0;
-  if (!(field in usage)) return void 0;
-  const candidate = usage[field];
-  return asOptionalFiniteNumber(candidate);
-};
-var readCostInUsdTicks = (usage) => readFiniteNumberField(usage, "cost_in_usd_ticks");
-var normalizeUsage = (usage) => {
-  if (!usage || typeof usage !== "object") {
-    return {
-      input_tokens: 0,
-      output_tokens: 0,
-      total_tokens: 0,
-      cache_creation_input_tokens: 0,
-      cache_read_input_tokens: 0,
-      cost: 0
-    };
-  }
-  const inputTokens = "input_tokens" in usage ? usage.input_tokens ?? 0 : "prompt_tokens" in usage ? usage.prompt_tokens : 0;
-  const outputTokens = "output_tokens" in usage ? usage.output_tokens ?? 0 : "completion_tokens" in usage ? usage.completion_tokens : 0;
-  const cacheCreationInputTokens = readCacheCreationInputTokens(usage);
-  const cacheReadInputTokens = readCacheReadInputTokens(usage);
-  let cost = 0;
-  const providedCost = readFiniteNumberField(usage, "cost");
-  if (providedCost !== void 0) {
-    cost = providedCost;
-  }
-  const xaiTicks = readCostInUsdTicks(usage);
-  if (xaiTicks !== void 0 && providedCost === void 0) {
-    cost = xaiTicks / 1e10;
-  }
-  const billingProvider = asOptionalTrimmedString(usage.billing_provider);
-  const billingModel = asOptionalTrimmedString(usage.billing_model);
-  const billingServiceTier = asOptionalTrimmedString(usage.billing_service_tier);
-  const billingEstimated = "billing_estimated" in usage && usage.billing_estimated === true;
-  const serverBilled = "server_billed" in usage && usage.server_billed === true;
-  const providerCallId = asOptionalTrimmedString(usage.provider_call_id);
-  const imageGenerationCount = "image_generation_count" in usage ? asOptionalFiniteNumber(usage.image_generation_count) : void 0;
-  const providerResponseIds = normalizeStringArray(
-    usage.provider_response_ids
-  );
-  const providerRequestIds = normalizeStringArray(
-    usage.provider_request_ids
-  );
-  const firstOutputMs = normalizeTimingMs(
-    readFiniteNumberField(usage, "firstOutputMs") ?? readFiniteNumberField(usage, "firstTokenMs")
-  );
-  const callDurationMs = normalizeTimingMs(
-    readFiniteNumberField(usage, "callDurationMs") ?? readFiniteNumberField(usage, "durationMs")
-  );
-  return {
-    input_tokens: inputTokens,
-    output_tokens: outputTokens,
-    total_tokens: finiteTokenCount(usage.total_tokens) ?? inputTokens + outputTokens,
-    cache_creation_input_tokens: cacheCreationInputTokens,
-    cache_read_input_tokens: cacheReadInputTokens,
-    cost,
-    ...typeof imageGenerationCount === "number" ? { image_generation_count: imageGenerationCount } : {},
-    ...providerResponseIds ? { provider_response_ids: providerResponseIds } : {},
-    ...providerRequestIds ? { provider_request_ids: providerRequestIds } : {},
-    ...billingProvider ? { billing_provider: billingProvider } : {},
-    ...billingModel ? { billing_model: billingModel } : {},
-    ...billingServiceTier ? { billing_service_tier: billingServiceTier } : {},
-    ...billingEstimated ? { billing_estimated: true } : {},
-    ...serverBilled ? { server_billed: true } : {},
-    ...providerCallId ? { provider_call_id: providerCallId } : {},
-    ...xaiTicks !== void 0 ? { cost_in_usd_ticks: xaiTicks } : {},
-    ...firstOutputMs !== void 0 ? { firstOutputMs } : {},
-    ...callDurationMs !== void 0 ? { callDurationMs } : {}
-  };
-};
-
-// packages/ai/token/resolveBillingTarget.ts
-var normalizeString2 = (value) => {
-  const trimmed = asTrimmedString(value);
-  return trimmed || void 0;
-};
-var resolveBillingModel = (usageModel, fallbackModel) => {
-  const model = normalizeString2(usageModel) ?? normalizeString2(fallbackModel);
-  if (!model) {
-    throw new Error("Billing model is required");
-  }
-  return model;
-};
-var resolveBillingTarget = ({
-  usage,
-  fallbackProvider,
-  fallbackModel
-}) => {
-  const provider = normalizeString2(usage?.billing_provider) ?? normalizeString2(fallbackProvider);
-  const model = resolveBillingModel(usage?.billing_model, fallbackModel);
-  const serviceTier = normalizeString2(usage?.billing_service_tier);
-  return {
-    provider,
-    model,
-    serviceTier
-  };
-};
-
-// packages/ai/token/usageConstants.ts
-var LOCAL_USER_ID = "local";
-
-// packages/ai/token/prepareTokenUsageData.ts
-function resolveTokenUsagePricing(args) {
-  const { rawUsage, agentConfig, nowMs } = args;
-  const usage = normalizeUsage(rawUsage);
-  const billingTarget = resolveBillingTarget({
-    usage,
-    fallbackProvider: agentConfig.provider,
-    fallbackModel: agentConfig.model
-  });
-  const billedProvider = billingTarget.provider;
-  const billedModel = billingTarget.model;
-  const billedServiceTier = billingTarget.serviceTier;
-  const canonicalAgentId = args.agentId?.trim();
-  const isCodeOwnedBuiltin = isBuiltinPlatformAgentKey(canonicalAgentId);
-  const isPlatformBilled = agentConfig.apiSource === "platform";
-  const hasPersistedPrices = agentConfig.inputPrice !== void 0 && agentConfig.inputPrice > 0 || agentConfig.outputPrice !== void 0 && agentConfig.outputPrice > 0;
-  if (isPlatformBilled && !isCodeOwnedBuiltin && hasPersistedPrices) {
-    console.warn(
-      `[billing] platform agent ignored persisted prices (input=${agentConfig.inputPrice}, output=${agentConfig.outputPrice}); canonical key missing or not in builtin set: "${canonicalAgentId || ""}"`
-    );
-  }
-  const hasExternalPrice = !isCodeOwnedBuiltin && !isPlatformBilled && hasPersistedPrices;
-  const { cost, pay } = calculatePrice({
-    provider: billedProvider,
-    modelName: billedModel,
-    billingServiceTier: billedServiceTier,
-    usage,
-    externalPrice: hasExternalPrice ? {
-      input: agentConfig.inputPrice ?? 0,
-      output: agentConfig.outputPrice ?? 0,
-      creatorId: agentConfig.userId ?? (agentConfig.id ? extractUserId(agentConfig.id) : "")
-    } : void 0,
-    sharingLevel: agentConfig.sharingLevel,
-    nowMs
-  });
-  return {
-    usage,
-    billedProvider,
-    billedModel,
-    billedServiceTier,
-    cost,
-    pay,
-    hasExternalPrice
-  };
-}
-function resolveBillable(input) {
-  const uid = input.userId?.trim();
-  if (!uid || uid === LOCAL_USER_ID) return false;
-  const apiSource = input.apiSource;
-  if (apiSource === "cli") return false;
-  if (isOAuthApiKeyRef(input.apiKeyRef)) return false;
-  if (input.cost <= 0) return false;
-  if (apiSource === "platform") return true;
-  if (apiSource === "custom") return input.hasExternalPrice;
-  if (apiSource == null || apiSource === "") return true;
-  return false;
-}
-function resolveBillableForAgent(input) {
-  const { usage, cost, userId, agentConfig } = input;
-  const hasExternalPrice = input.hasExternalPrice ?? (agentConfig.inputPrice !== void 0 && agentConfig.inputPrice > 0 || agentConfig.outputPrice !== void 0 && agentConfig.outputPrice > 0);
-  return resolveBillable({
-    usage,
-    userId,
-    apiSource: agentConfig.apiSource,
-    apiKeyRef: agentConfig.apiKeyRef,
-    cost,
-    hasExternalPrice
-  });
-}
-var prepareTokenUsageData = ({
-  rawUsage,
-  agentConfig,
-  userId,
-  username,
-  agentId,
-  cybotId,
-  dialogId,
-  timestamp = Date.now(),
-  stable_prefix_hash,
-  stable_prefix_estimated_tokens,
-  entry_path
-}) => {
-  const resolvedAgentId = typeof agentId === "string" && agentId.trim() || typeof cybotId === "string" && cybotId.trim() || "";
-  const { usage, billedProvider, billedModel, billedServiceTier, cost, pay, hasExternalPrice } = resolveTokenUsagePricing({
-    rawUsage,
-    agentConfig,
-    agentId: resolvedAgentId,
-    nowMs: timestamp
-  });
-  const recordProvider = billedProvider ?? agentConfig.provider ?? "unknown";
-  const billable = resolveBillableForAgent({
-    usage,
-    cost,
-    userId,
-    agentConfig,
-    hasExternalPrice
-  });
-  return {
-    usage,
-    billedProvider,
-    billedModel,
-    billedServiceTier,
-    recordProvider,
-    tokenData: {
-      ...usage,
-      userId,
-      username,
-      agentId: resolvedAgentId,
-      cybotId: resolvedAgentId,
-      model: billedModel,
-      provider: recordProvider,
-      billing_service_tier: billedServiceTier,
-      dialogId,
-      cost,
-      pay,
-      timestamp,
-      billable,
-      ...stable_prefix_hash !== void 0 ? { stable_prefix_hash } : {},
-      ...stable_prefix_estimated_tokens !== void 0 ? { stable_prefix_estimated_tokens } : {},
-      ...entry_path !== void 0 ? { entry_path } : {}
-    }
-  };
-};
-
-// packages/ai/token/applyTokenUsageToDayStats.ts
-var ZERO_STATS = {
-  count: 0,
-  tokens: { input: 0, output: 0, cacheRead: 0, cacheCreation: 0 },
-  cost: 0,
-  failedCount: 0
-};
-function normalizeStats(s) {
-  if (!s) return { ...ZERO_STATS };
-  const t = s.tokens;
-  return {
-    count: s.count ?? 0,
-    tokens: {
-      input: t?.input ?? 0,
-      output: t?.output ?? 0,
-      cacheRead: t?.cacheRead ?? t?.cache_read ?? 0,
-      cacheCreation: t?.cacheCreation ?? t?.cache_creation ?? 0
-    },
-    cost: s.cost ?? 0,
-    failedCount: s.failedCount ?? 0
-  };
-}
-function normalizeDayStats(prev, userId, timeKey) {
-  if (!prev) {
-    return {
-      userId,
-      period: "day",
-      timeKey,
-      total: { ...ZERO_STATS },
-      models: {},
-      providers: {},
-      agents: {},
-      entryPaths: {},
-      categories: {},
-      modelCategories: {}
-    };
-  }
-  const normalizeMap = (m) => {
-    if (!m) return {};
-    const out = {};
-    for (const [k, v] of Object.entries(m)) out[k] = normalizeStats(v);
-    return out;
-  };
-  const normalizedTotal = normalizeStats(prev.total);
-  const normalizedModels = normalizeMap(prev.models);
-  const normalizedProviders = normalizeMap(prev.providers);
-  const normalizedAgents = normalizeMap(prev.agents);
-  const normalizedEntryPaths = normalizeMap(prev.entryPaths);
-  let categories = normalizeMap(prev.categories);
-  let modelCategories = normalizeMap(prev.modelCategories);
-  const hasCategories = Object.keys(categories).length > 0;
-  const hasModelCategories = Object.keys(modelCategories).length > 0;
-  if (!hasCategories) {
-    const hasActivity = normalizedTotal.count > 0 || normalizedTotal.failedCount > 0 || normalizedTotal.cost > 0 || normalizedTotal.tokens.input > 0 || normalizedTotal.tokens.output > 0;
-    if (hasActivity) {
-      categories = { platform: { ...normalizedTotal } };
-    }
-  }
-  if (!hasModelCategories && Object.keys(normalizedModels).length > 0) {
-    const legacyModelCats = {};
-    for (const [modelKey, modelStat] of Object.entries(normalizedModels)) {
-      legacyModelCats[`${modelKey}:::platform`] = { ...modelStat };
-    }
-    modelCategories = legacyModelCats;
-  }
-  return {
-    ...prev,
-    total: normalizedTotal,
-    models: normalizedModels,
-    providers: normalizedProviders,
-    agents: normalizedAgents,
-    entryPaths: normalizedEntryPaths,
-    categories,
-    modelCategories
-  };
-}
-function applyTokenUsageToDayStats(prev, delta) {
-  const base = normalizeDayStats(prev, delta.userId, delta.timeKey);
-  const modelName = delta.model || "unknown";
-  const providerName = delta.provider || "unknown";
-  const cacheRead = delta.cache_read_input_tokens ?? 0;
-  const cacheCreation = delta.cache_creation_input_tokens ?? 0;
-  const isFailed = delta.status === "failed";
-  const category = delta.billingCategory || "platform";
-  const modelCategoryKey = `${modelName}:::${category}`;
-  const inc = (s) => {
-    const n = normalizeStats(s);
-    if (isFailed) {
-      return {
-        ...n,
-        failedCount: n.failedCount + 1
-      };
-    }
-    return {
-      count: n.count + 1,
-      tokens: {
-        input: n.tokens.input + delta.input_tokens,
-        output: n.tokens.output + delta.output_tokens,
-        cacheRead: n.tokens.cacheRead + cacheRead,
-        cacheCreation: n.tokens.cacheCreation + cacheCreation
-      },
-      // 非计费记录（订阅/OAuth/CLI，billable=false）不向平台积分统计贡献 cost：
-      // 订阅已付费、不按 token 计费，若不归零，图表「成本」视图会把订阅用量误显示为积分消耗。
-      cost: Number((n.cost + (category === "subscription" ? 0 : delta.cost)).toFixed(6)),
-      failedCount: n.failedCount
-    };
-  };
-  const result = {
-    ...base,
-    total: inc(base.total),
-    models: {
-      ...base.models,
-      [modelName]: inc(base.models[modelName])
-    },
-    providers: {
-      ...base.providers,
-      [providerName]: inc(base.providers[providerName])
-    },
-    categories: {
-      ...base.categories,
-      [category]: inc(base.categories?.[category])
-    },
-    modelCategories: {
-      ...base.modelCategories,
-      [modelCategoryKey]: inc(base.modelCategories?.[modelCategoryKey])
-    }
-  };
-  if (delta.agentId !== void 0) {
-    const agentKey = delta.agentId || "unknown";
-    result.agents = {
-      ...base.agents,
-      [agentKey]: inc(base.agents[agentKey])
-    };
-  }
-  if (delta.entry_path !== void 0) {
-    const entryKey = delta.entry_path || "unknown";
-    result.entryPaths = {
-      ...base.entryPaths,
-      [entryKey]: inc(base.entryPaths[entryKey])
-    };
-  }
-  return result;
-}
-
-// packages/core/keyedTaskQueue.ts
-var queues = /* @__PURE__ */ new Map();
-async function runKeyed(key, task) {
-  const previous = queues.get(key) ?? Promise.resolve();
-  const next = previous.catch(() => void 0).then(task);
-  const cleanup = next.then(
-    () => void 0,
-    () => void 0
-  );
-  queues.set(key, cleanup);
-  try {
-    return await next;
-  } finally {
-    if (queues.get(key) === cleanup) {
-      queues.delete(key);
-    }
-  }
-}
-
-// packages/chat/dialog/actions/updateTokensAction.ts
-var logger2 = createClientLogger("token-usage");
-var dialogTokenPatchQueue = /* @__PURE__ */ new Map();
-var queueDialogTokenPatch = async (dialogKey, task) => {
-  const previousTask = dialogTokenPatchQueue.get(dialogKey) ?? Promise.resolve();
-  const nextTask = previousTask.catch(() => void 0).then(task);
-  const queueEntry = nextTask.then(
-    () => void 0,
-    () => void 0
-  );
-  dialogTokenPatchQueue.set(dialogKey, queueEntry);
-  try {
-    return await nextTask;
-  } finally {
-    if (dialogTokenPatchQueue.get(dialogKey) === queueEntry) {
-      dialogTokenPatchQueue.delete(dialogKey);
-    }
-  }
-};
-var updateStats = async (data, existingStats, key, thunkApi) => {
-  try {
-    const dateKey = (0, import_date_fns.format)(data.timestamp ?? Date.now(), "yyyy-MM-dd");
-    const newStats = applyTokenUsageToDayStats(existingStats, {
-      userId: data.userId ?? "",
-      timeKey: dateKey,
-      model: data.model || "unknown",
-      provider: data.provider || "unknown",
-      input_tokens: data.input_tokens,
-      output_tokens: data.output_tokens,
-      cost: data.cost,
-      cache_read_input_tokens: data.cache_read_input_tokens,
-      cache_creation_input_tokens: data.cache_creation_input_tokens,
-      agentId: data.agentId ?? data.cybotId,
-      entry_path: data.entry_path,
-      billingCategory: data.billable ? "platform" : "subscription"
-    });
-    await thunkApi.dispatch(
-      write({
-        data: { ...newStats, id: key, type: "token" /* TOKEN */ },
-        customKey: key,
-        userId: data.userId
-      })
-    ).unwrap();
-    return newStats;
-  } catch (error) {
-    logger2.error(
-      { key, userId: data.userId, error: error.message },
-      "Failed to update token stats"
-    );
-    toast.error("Failed to update token stats");
-    throw error;
-  }
-};
-var saveTokenUsage = async (data, thunkApi) => {
-  const dateKey = (0, import_date_fns.format)(data.timestamp ?? Date.now(), "yyyy-MM-dd");
-  const tokenDayStatsKey = createTokenStatsKey(data.userId ?? "", dateKey);
-  return runKeyed(tokenDayStatsKey, async () => {
-    try {
-      let currentStats = null;
-      try {
-        currentStats = await thunkApi.dispatch(read({
-          dbKey: tokenDayStatsKey
-        })).unwrap();
-      } catch (err) {
-        logger2.warn({ tokenDayStatsKey }, "No existing stats found");
-      }
-      const updatedStats = await updateStats(
-        data,
-        currentStats,
-        tokenDayStatsKey,
-        thunkApi
-      );
-      return {
-        success: true,
-        id: ulid(Date.now()),
-        record: updatedStats
-      };
-    } catch (error) {
-      logger2.error(
-        {
-          key: tokenDayStatsKey,
-          userId: data.userId,
-          error: error.message,
-          tokenData: {
-            input: data.input_tokens,
-            output: data.output_tokens,
-            model: data.model
-          }
-        },
-        "Failed to process token usage"
-      );
-      toast.error("Failed to process token usage");
-      throw error;
-    }
-  });
-};
-var updateTokensAction = async ({ dialogId, dialogKey, usage: legacyUsage, usageRecord, agentConfig }, thunkApi) => {
-  const state = thunkApi.getState();
-  const currentUser = selectIdentityUser(state);
-  const dialogConfig = dialogKey ? selectById(state, dialogKey) : null;
-  const dialogConfigUserId = dialogConfig?.userId;
-  const ownerUserId = resolveMessageOwner({
-    dialogConfigUserId: typeof dialogConfigUserId === "string" ? dialogConfigUserId : null,
-    dialogKey: typeof dialogKey === "string" ? dialogKey : "",
-    currentAccountUserId: currentUser?.userId ?? null
-  });
-  const timestamp = Date.now();
-  const usageRaw = usageRecord?.usage ?? legacyUsage;
-  const callId = (typeof usageRecord?.callId === "string" && usageRecord.callId.trim() ? usageRecord.callId.trim() : void 0) ?? (typeof usageRaw?.provider_call_id === "string" && usageRaw.provider_call_id.trim() ? usageRaw.provider_call_id.trim() : void 0);
-  const usageWithStableCallId = callId && !usageRaw?.provider_call_id ? { ...usageRaw, provider_call_id: callId } : usageRaw;
-  const callAgentConfig = {
-    ...agentConfig,
-    ...typeof usageRecord?.model === "string" ? { model: usageRecord.model } : {},
-    ...typeof usageRecord?.provider === "string" ? { provider: usageRecord.provider } : {}
-  };
-  const prepared = prepareTokenUsageData({
-    rawUsage: usageWithStableCallId,
-    agentConfig: callAgentConfig,
-    userId: ownerUserId,
-    username: currentUser?.username,
-    // agentConfig.id is the canonical ulid; dbKey (agent-<userId>-<id>) is
-    // always present on db records. Quick-chat may construct agentConfig with
-    // only dbKey, so fall back to keep billing working (matches serverTokenWriter
-    // which passes agentKey = dbKey directly).
-    agentId: agentConfig.id || agentConfig.dbKey,
-    dialogId,
-    timestamp,
-    entry_path: "web-chat"
-  });
-  const { usage, tokenData, recordProvider, billedModel } = prepared;
-  const result = { cost: tokenData.cost, pay: tokenData.pay };
-  const persistedTokenData = {
-    ...tokenData,
-    type: "token" /* TOKEN */,
-    id: ulid(timestamp),
-    dateKey: (0, import_date_fns.format)(timestamp, "yyyy-MM-dd"),
-    // Keep the same clock used for id/dateKey so record keys never see
-    // undefined when a prepare helper omits timestamp.
-    timestamp
-  };
-  const stableTokenKey = callId ? createTokenKey.recordForStableCall(ownerUserId, callId) : null;
-  const accountingAlreadyProjected = stableTokenKey ? Boolean(selectById(state, stableTokenKey)) : false;
-  const billedCatalog = findModelConfig(recordProvider, billedModel)?.price;
-  const record = createTokenRecord(persistedTokenData, {
-    cost: result.cost,
-    inputPrice: billedCatalog?.input ?? agentConfig.inputPrice,
-    outputPrice: billedCatalog?.output ?? agentConfig.outputPrice
-  });
-  await saveTokenRecord(persistedTokenData, record, thunkApi, callId);
-  if (accountingAlreadyProjected) {
-    return {
-      input_tokens: usage.input_tokens,
-      output_tokens: usage.output_tokens,
-      cost: result.cost
-    };
-  }
-  await saveTokenUsage(persistedTokenData, thunkApi);
-  if (persistedTokenData.billable === true || persistedTokenData.billable === void 0 && result.cost > 0) {
-    thunkApi.extra?.accountSession?.deductBalance(result.cost);
-  }
-  if (dialogKey) {
-    await queueDialogTokenPatch(dialogKey, async () => {
-      const latestState = thunkApi.getState();
-      const dialogConfig2 = selectById(latestState, dialogKey) ?? await thunkApi.dispatch(read({ dbKey: dialogKey })).unwrap();
-      if (!dialogConfig2) {
-        throw new Error(`Dialog not found for token update: ${dialogKey}`);
-      }
-      await thunkApi.dispatch(
-        patch({
-          dbKey: dialogKey,
-          changes: {
-            inputTokens: (dialogConfig2.inputTokens ?? 0) + usage.input_tokens,
-            outputTokens: (dialogConfig2.outputTokens ?? 0) + usage.output_tokens,
-            totalCost: (dialogConfig2.totalCost ?? 0) + result.cost
-          }
-        })
-      ).unwrap();
-    });
-  }
-  return {
-    input_tokens: usage.input_tokens,
-    output_tokens: usage.output_tokens,
-    cost: result.cost
-  };
-};
-
-// packages/chat/dialog/dialogTokenStats.ts
-var mergeDialogTokenStats = (dialogConfig, runtimeTokens) => ({
-  inputTokens: (dialogConfig?.inputTokens ?? 0) + runtimeTokens.inputTokens,
-  outputTokens: (dialogConfig?.outputTokens ?? 0) + runtimeTokens.outputTokens,
-  totalCost: (dialogConfig?.totalCost ?? 0) + runtimeTokens.totalCost
-});
-
-// packages/chat/dialog/deleteDialogOrchestration.ts
-var collectKeys = async (prefix, db) => {
-  const keys = [];
-  let iterator = db.iterator({
-    gte: prefix,
-    lte: prefix + "\uFFFF"
-  });
-  if (iterator && typeof iterator.then === "function") {
-    iterator = await iterator;
-  }
-  for await (const [key] of iterator) {
-    keys.push(key);
-  }
-  return keys;
-};
-var collectEntries = async (prefix, db) => {
-  const entries = [];
-  let iterator = db.iterator({
-    gte: prefix,
-    lte: prefix + "\uFFFF"
-  });
-  if (iterator && typeof iterator.then === "function") {
-    iterator = await iterator;
-  }
-  for await (const [key, value] of iterator) {
-    entries.push([key, value]);
-  }
-  return entries;
-};
-var dbGetOrNull = async (db, key) => {
-  if (!db || typeof db.get !== "function") return null;
-  try {
-    return await db.get(key);
-  } catch {
-    return null;
-  }
-};
-var readLocalFileMetadata = async (db, fileId) => {
-  const direct = await dbGetOrNull(db, fileId);
-  if (direct) return direct;
-  const index = await dbGetOrNull(db, createKey("file", "id", fileId));
-  const mainKey = asOptionalTrimmedString(index?.mainKey) ?? null;
-  return mainKey ? await dbGetOrNull(db, mainKey) : null;
-};
-var normalizeDeleteDialogPayload = (payload) => typeof payload === "string" ? { dialogKey: payload, includeAttachments: false } : {
-  dialogKey: payload.dialogKey,
-  includeAttachments: payload.includeAttachments === true
-};
-var deleteOwnedDialogAttachments = async (args) => {
-  const messages = args.entries.map(
-    ([dbKey, value]) => ({
-      ...asRecordOrEmpty(value),
-      dbKey
-    })
-  );
-  const fileIds = [
-    ...new Set(messages.flatMap((message) => extractFileContentIds(message)))
-  ];
-  const metadataByFileId = {};
-  const metadataReadFailures = [];
-  for (const fileId of fileIds) {
-    const metadata = await readLocalFileMetadata(args.db, fileId);
-    if (metadata) {
-      metadataByFileId[fileId] = metadata;
-    } else {
-      metadataReadFailures.push({
-        fileId,
-        error: "local file metadata not found"
-      });
-    }
-  }
-  const plan = buildDialogAttachmentPlan({
-    dialogId: args.dialogId,
-    messages,
-    metadataByFileId,
-    metadataReadFailures
-  });
-  if (!plan.deleteCandidates.length) return plan;
-  const { deleteFileAction } = await import("./deleteFile-LWSR674W.js");
-  for (const candidate of plan.deleteCandidates) {
-    if (candidate.fileDbKey) {
-      await deleteFileAction(candidate.fileDbKey, args.thunkApi);
-    }
-  }
-  return plan;
-};
-var deleteDialogThunk = async (payload, thunkApi) => {
-  const { dialogKey, includeAttachments } = normalizeDeleteDialogPayload(payload);
-  const { dispatch, getState, extra } = thunkApi;
-  const { db } = extra;
-  const state = getState();
-  const { currentServer, syncServers } = getRuntimeServerContext(state);
-  const currentDialogKey = getActiveDialogKey();
-  const currentDialogId = currentDialogKey ? extractCustomId(currentDialogKey) : null;
-  const targetDialogId = extractCustomId(dialogKey);
-  const targetDialogConfig = selectById(state, dialogKey);
-  const isCurrentDialog = currentDialogId !== null && currentDialogId === targetDialogId;
-  await cleanupCliSessionForDialog(
-    { dispatch, getState },
-    targetDialogConfig
-  );
-  const dialogOwnerId = typeof targetDialogConfig?.userId === "string" && String(targetDialogConfig.userId).trim() || (() => {
-    const rest = dialogKey.startsWith("dialog-") ? dialogKey.slice("dialog-".length) : "";
-    const last = rest.lastIndexOf("-");
-    return last > 0 ? rest.slice(0, last) : "";
-  })();
-  const agentListIndexDels = buildDialogAgentListIndexDeleteOps({
-    userId: dialogOwnerId,
-    dialogKey,
-    dialogId: targetDialogId || void 0,
-    previousRecord: targetDialogConfig ? targetDialogConfig : null
-  });
-  await dispatch(remove(dialogKey));
-  const prefix = createKey("dialog", targetDialogId, "msg");
-  const deletedEntries = includeAttachments ? await collectEntries(prefix, db) : [];
-  const attachmentPlan = includeAttachments && targetDialogId ? await deleteOwnedDialogAttachments({
-    db,
-    dialogId: targetDialogId,
-    entries: deletedEntries,
-    thunkApi
-  }) : null;
-  const deletedIds = includeAttachments ? deletedEntries.map(([key]) => key) : await collectKeys(prefix, db);
-  const ops = [
-    ...agentListIndexDels,
-    ...deletedIds.map((key) => ({ type: "del", key }))
-  ];
-  if (ops.length > 0) {
-    await db.batch(ops);
-  }
-  if (deletedIds.length > 0) {
-    scheduleDeleteReplication({
-      currentServer,
-      syncServers,
-      dbKey: targetDialogId,
-      deleteOptions: { type: "messages" },
-      state
-    });
-  }
-  if (isCurrentDialog) {
-    await thunkApi.dispatch(resetMsgs());
-    const { clearPendingAttachments: clearPendingAttachments2 } = await import("./dialogSlice-DEC5GV6X.js");
-    dispatch(clearPendingAttachments2());
-  }
-  return { dialogKey, isCurrentDialog, attachmentPlan };
-};
-
-// packages/chat/dialog/dialogSlice.ts
-var runCreateDialogAction = async (args, thunkApi) => {
-  const { createDialogAction } = await import("./createDialogAction-SFMZLPS4.js");
-  return createDialogAction(args, thunkApi);
-};
-var runCreateAgentAutomationAction = async (args, thunkApi) => {
-  const { createAgentAutomationAction } = await import("./createAgentAutomationAction-K5YJO4IA.js");
-  return createAgentAutomationAction(args, thunkApi);
-};
-var runUpdateDialogTitleAction = async (args, thunkApi) => {
-  const { updateDialogTitleAction } = await import("./updateDialogTitleAction-L6CCRVUK.js");
-  return updateDialogTitleAction(args, thunkApi);
-};
-var runAddDialogAgentAction = async (args, thunkApi) => {
-  const { addDialogAgentAction } = await import("./addDialogAgentAction-EUBNJ5SS.js");
-  return addDialogAgentAction(args, thunkApi);
-};
-var runRemoveDialogAgentAction = async (args, thunkApi) => {
-  const { removeDialogAgentAction } = await import("./removeDialogAgentAction-BVU6E27N.js");
-  return removeDialogAgentAction(args, thunkApi);
-};
-var runSetPrimaryDialogAgentAction = async (args, thunkApi) => {
-  const { setPrimaryDialogAgentAction } = await import("./setPrimaryDialogAgentAction-HMHZWURC.js");
-  return setPrimaryDialogAgentAction(args, thunkApi);
-};
-var runSwitchDialogAgentAction = async (args, thunkApi) => {
-  const { switchDialogAgentAction } = await import("./switchDialogAgentAction-Y66ZTIGP.js");
-  return switchDialogAgentAction(args, thunkApi);
-};
-var runSetDialogExtraReferencesAction = async (args, thunkApi) => {
-  const { setDialogExtraReferencesAction } = await import("./setDialogExtraReferencesAction-AUKADSTQ.js");
-  return setDialogExtraReferencesAction(args, thunkApi);
-};
-var runHandleSendMessageAction = async (args, thunkApi) => {
-  const { handleSendMessageAction } = await import("./handleSendMessageAction-C7CZNGMB.js");
-  return handleSendMessageAction(args, thunkApi);
-};
-function clearDialogState() {
-  applyClearDialogStateRuntime();
-  return { type: "dialog/clearDialogState" };
-}
-clearDialogState.type = "dialog/clearDialogState";
-var createPageAndAddReference = createAsyncThunk(
-  "dialog/createPageAndAddReference",
-  async (payload, { dispatch, getState, rejectWithValue }) => {
-    const { slateData, jsonData, title, type, fileId, groupId, dialogKey } = payload;
-    try {
-      const { createDocState } = await import("./docStore-IBPCRTTX.js");
-      const pageKey = await createDocState(
-        { slateData, title },
-        { dispatch, getState }
-      );
-      const newReference = {
-        id: fileId,
-        name: title,
-        pageKey,
-        dialogKey,
-        type,
-        groupId
-      };
-      const newRawData = jsonData ? { pageKey, jsonData } : null;
-      addPageReferenceToRuntime({
-        reference: newReference,
-        rawData: newRawData,
-        dialogKey
-      });
-      return { reference: newReference, rawData: newRawData, dialogKey };
-    } catch (error) {
-      console.error("\u521B\u5EFA\u9875\u9762\u6216\u5F15\u7528\u5931\u8D25:", error);
-      return rejectWithValue(error.message);
-    }
-  }
-);
-var deleteDialog = createAsyncThunk(
-  "dialog/deleteDialog",
-  async (payload, thunkApi) => {
-    const result = await deleteDialogThunk(payload, thunkApi);
-    deleteDialogRuntime(result.dialogKey);
-    if (result.isCurrentDialog) {
-      setActiveDialogKey(null);
-    }
-    return result;
-  }
-);
-var initDialog = createAsyncThunk(
-  "dialog/initDialog",
-  async (id, { dispatch, signal, getState }) => {
-    setActiveDialogKey(id);
-    resetDialogRuntimeSessionState(id);
-    try {
-      const { currentServer: preferredServerOrigin } = getRuntimeServerContext(
-        getState()
-      );
-      return await dispatch(
-        read({
-          dbKey: id,
-          signal,
-          preferredServerOrigin
-        })
-      ).unwrap();
-    } catch (error) {
-      const err = error;
-      const isAborted = isAbortError(err) || err?.message === "Aborted";
-      const isCurrentDialog = getActiveDialogKey() === id;
-      if (!isAborted && isCurrentDialog) {
-        setDialogConfigError(err?.message || "Failed to load dialog");
-        console.info("Failed to load dialog config:", err?.message);
-      }
-      throw error;
-    }
-  }
-);
-var handleSendMessage = createAsyncThunk(
-  "dialog/handleSendMessage",
-  runHandleSendMessageAction
-);
-var abortAllMessages = createAsyncThunk(
-  "dialog/abortAllMessages",
-  async (args, { dispatch }) => {
-    abortActiveControllers(args);
-    dispatch(clearAllStreaming(args));
-    clearActiveControllers(args);
-  }
-);
-var updateTokens = createAsyncThunk(
-  "dialog/updateTokens",
-  async (args, thunkApi) => {
-    const payload = await updateTokensAction(args, thunkApi);
-    const dialogKey = args?.dialogKey;
-    if (dialogKey && payload) {
-      applyUpdateTokensFulfilled({
-        dialogKey,
-        input_tokens: payload.input_tokens,
-        output_tokens: payload.output_tokens,
-        cost: payload.cost
-      });
-    }
-    return payload;
-  }
-);
-var createDialog = createAsyncThunk(
-  "dialog/createDialog",
-  runCreateDialogAction
-);
-var createAgentAutomation = createAsyncThunk(
-  "dialog/createAgentAutomation",
-  runCreateAgentAutomationAction
-);
-var updateDialogTitle = createAsyncThunk(
-  "dialog/updateDialogTitle",
-  runUpdateDialogTitleAction
-);
-var addDialogAgent = createAsyncThunk(
-  "dialog/addDialogAgent",
-  runAddDialogAgentAction
-);
-var removeDialogAgent = createAsyncThunk(
-  "dialog/removeDialogAgent",
-  runRemoveDialogAgentAction
-);
-var setPrimaryDialogAgent = createAsyncThunk(
-  "dialog/setPrimaryDialogAgent",
-  runSetPrimaryDialogAgentAction
-);
-var switchDialogAgent = createAsyncThunk(
-  "dialog/switchDialogAgent",
-  runSwitchDialogAgentAction
-);
-var setDialogExtraReferences = createAsyncThunk(
-  "dialog/setDialogExtraReferences",
-  runSetDialogExtraReferencesAction
-);
-function selectCurrentDialogConfig(state) {
-  const key = getActiveDialogKey();
-  return key ? selectById(state, key) : null;
-}
-var selectCurrentDialogAgentIds = createSelector(
-  (state) => selectCurrentDialogConfig(state),
-  (dialogConfig) => getDialogAgentIds(dialogConfig)
-);
-var selectCurrentPrimaryAgentId = createSelector(
-  (state) => selectCurrentDialogConfig(state),
-  (dialogConfig) => getPrimaryDialogAgentId(dialogConfig)
-);
-var selectDialogConfigByKey = createSelector(
-  (state) => state,
-  (_, dialogKey) => dialogKey,
-  (state, dialogKey) => dialogKey ? selectById(state, dialogKey) : null
-);
-var selectCurrentDialogTokens = createSelector(
-  (state) => state,
-  selectCurrentDialogConfig,
-  (_state, dialogKey) => dialogKey,
-  (state, currentDialog, dialogKey) => {
-    if (dialogKey) {
-      const dialogConfig = selectById(state, dialogKey);
-      return mergeDialogTokenStats(
-        dialogConfig,
-        getDialogRuntimeTokens(dialogKey)
-      );
-    }
-    return mergeDialogTokenStats(currentDialog, getDialogRuntimeTokens());
-  }
-);
-var selectTotalDialogTokens = selectCurrentDialogTokens;
-
-export {
-  isAssistantToolStub,
-  fetchAndCacheMessages,
-  extractReferenceKeysFromMessage,
-  normalizeAppRouteId,
-  uiAskChoiceFunctionSchema,
-  uiAskChoiceFunc,
-  parseUiAskChoiceContent,
-  PERSONALIZATION_DIALOG_CATEGORY,
-  buildPersonalizationDialogPolicyContext,
-  resolveBuiltinPlatformAgentConfig,
-  resolveBuiltinPlatformAgentRecord,
-  applyBuiltinAgentRuntimeOverride,
-  resolveDialogRuntimeAgentKey,
-  resolveHandleSendMessageContext,
-  estimateMissingUsage,
-  selectCurrentDialogId,
-  selectAllMsgs,
-  selectMsgById,
-  addUserMessage,
-  messageStreaming,
-  removeTransientMessage,
-  finalizeTransientMessageOnError,
-  prepareAndPersistMessage,
-  prepareAndPersistUserMessage,
-  messageStreamEnd,
-  addToolMessage,
-  updateToolMessage,
-  toast,
-  API_REPORTED_COST_MULTIPLIER,
-  normalizeUsage,
-  prepareTokenUsageData,
-  applyTokenUsageToDayStats,
-  runKeyed,
-  updateTokensAction,
-  clearDialogState,
-  createPageAndAddReference,
-  deleteDialog,
-  initDialog,
-  handleSendMessage,
-  abortAllMessages,
-  updateTokens,
-  createDialog,
-  createAgentAutomation,
-  updateDialogTitle,
-  addDialogAgent,
-  removeDialogAgent,
-  setPrimaryDialogAgent,
-  switchDialogAgent,
-  setDialogExtraReferences,
-  selectCurrentDialogConfig,
-  selectCurrentDialogAgentIds,
-  selectCurrentPrimaryAgentId,
-  selectDialogConfigByKey,
-  selectCurrentDialogTokens,
-  selectTotalDialogTokens
-};