tavern-harness 0.1.13 → 0.1.14

package/src/core/avatarThumbnail.ts

@@ -0,0 +1,245 @@
+/** 缓存大尺寸位图头像的展示缩略图。 */
+import { useEffect, useLayoutEffect, useSyncExternalStore } from 'react';
+
+/** 超过该长度的 data URL 才值得缩略（约 72 KB 图片；再小的解析成本可忽略）。 */
+export const AVATAR_THUMBNAIL_THRESHOLD = 96 * 1024;
+
+/** 缩略图边长：最大展示尺寸 40px，128px 足够覆盖 3x DPR。 */
+const AVATAR_THUMBNAIL_SIZE = 128;
+
+/** 入库缩略图边长：比展示尺寸大一档，兼顾高 DPI 与二次导出。 */
+export const AVATAR_STORAGE_SIZE = 256;
+
+/** 缓存条数 + 总字符双上限：原图 data URL 作为 key 时，单条也可能很大。 */
+const CACHE_LIMIT = 128;
+const CACHE_MAX_CHARS = 4 * 1024 * 1024;
+
+/** 可安全缩略的位图 data URL；GIF/SVG 跳过（保留动图与矢量）。 */
+const THUMBNAILABLE_DATA_URL = /^data:image\/(?:png|jpe?g|webp|bmp|avif);base64,/i;
+
+type ThumbnailState =
+  | { status: 'pending'; thumb: null }
+  | { status: 'ready'; thumb: string }
+  | { status: 'original'; thumb: null };
+
+const cache = new Map<string, ThumbnailState>();
+/** 当前挂载中的头像 URL：正在显示的条目不允许被预算淘汰，否则会“文字头像 ⇄ 图片头像”反复闪。 */
+const activeUrls = new Map<string, number>();
+const listeners = new Set<() => void>();
+const queue: string[] = [];
+const queued = new Set<string>();
+let cachedChars = 0;
+let pumping = false;
+
+/** 是否是值得生成缩略图的超大位图 data URL。 */
+export function isOversizedAvatarUrl(url: string | null | undefined): boolean {
+  return Boolean(url && url.length > AVATAR_THUMBNAIL_THRESHOLD && THUMBNAILABLE_DATA_URL.test(url));
+}
+
+function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+function notify(): void {
+  for (const listener of listeners) listener();
+}
+
+function entryChars(url: string, state: ThumbnailState): number {
+  return url.length + (state.thumb?.length ?? 0);
+}
+
+function setCacheEntry(url: string, state: ThumbnailState): void {
+  const previous = cache.get(url);
+  if (previous) cachedChars -= entryChars(url, previous);
+  cache.set(url, state);
+  cachedChars += entryChars(url, state);
+}
+
+function deleteCacheEntry(url: string): void {
+  const entry = cache.get(url);
+  if (!entry) return;
+  cachedChars -= entryChars(url, entry);
+  cache.delete(url);
+}
+
+function trimCache(): void {
+  while ((cache.size > CACHE_LIMIT || cachedChars > CACHE_MAX_CHARS) && cache.size > 1) {
+    // 只淘汰已经不在界面上的条目；全部都在用时宁可暂时超出预算，
+    // 否则刚生成好的缩略图会被立刻删掉，然后又在同一个组件里重建。
+    let victim: string | undefined;
+    for (const key of cache.keys()) {
+      if (!activeUrls.has(key)) {
+        victim = key;
+        break;
+      }
+    }
+    if (victim == null) break;
+    deleteCacheEntry(victim);
+  }
+}
+
+/** 命中即移到队尾（Map 的插入顺序就是淘汰顺序）。 */
+function touchCacheEntry(url: string): void {
+  const entry = cache.get(url);
+  if (!entry) return;
+  cache.delete(url);
+  cache.set(url, entry);
+}
+
+function requestIdle(callback: () => void): void {
+  const idle = (globalThis as { requestIdleCallback?: (cb: () => void, options?: { timeout: number }) => number }).requestIdleCallback;
+  if (typeof idle === 'function') {
+    idle(callback, { timeout: 500 });
+    return;
+  }
+  globalThis.setTimeout(callback, 50);
+}
+
+function enqueue(url: string): void {
+  if (cache.has(url) || queued.has(url)) return;
+  setCacheEntry(url, { status: 'pending', thumb: null });
+  trimCache();
+  queue.push(url);
+  queued.add(url);
+  if (!pumping) {
+    pumping = true;
+    requestIdle(() => void pump());
+  }
+}
+
+async function pump(): Promise<void> {
+  const url = queue.shift();
+  if (url) queued.delete(url);
+  if (!url) {
+    pumping = false;
+    return;
+  }
+  // 排队期间可能已被缓存淘汰：补回 pending，避免同一 URL 永远没有结果
+  if (!cache.has(url)) {
+    setCacheEntry(url, { status: 'pending', thumb: null });
+    trimCache();
+  }
+  try {
+    const thumb = await renderThumbnail(url, AVATAR_THUMBNAIL_SIZE);
+    setCacheEntry(url, { status: 'ready', thumb });
+  } catch {
+    // 解码失败（损坏图片 / 不支持的格式）就退回原图，不反复重试
+    setCacheEntry(url, { status: 'original', thumb: null });
+  }
+  notify();
+  trimCache();
+  if (queue.length > 0) {
+    // 逐个错开：连续生成多张大图时给浏览器留出渲染/交互的间隙
+    globalThis.setTimeout(() => requestIdle(() => void pump()), 80);
+    return;
+  }
+  pumping = false;
+}
+
+/**
+ * 生成缩略图 data URL（仅浏览器可用）。
+ * 用 createImageBitmap 的 resize 选项把缩放交给解码器，避免 drawImage 大幅缩小
+ * 时在主线程上做昂贵的重采样；不支持时退回 drawImage。
+ */
+async function renderThumbnail(dataUrl: string, size: number): Promise<string> {
+  const image = new Image();
+  image.decoding = 'async';
+  image.src = dataUrl;
+  await image.decode();
+
+  // 与 CSS 的 background-size: cover 一致：先按短边居中裁出正方形，再缩放。
+  // 直接拉成 128×128 会把非正方形头像压扁/拉长。
+  const width = image.naturalWidth || image.width;
+  const height = image.naturalHeight || image.height;
+  const side = Math.max(1, Math.min(width, height));
+  const sx = Math.max(0, Math.round((width - side) / 2));
+  const sy = Math.max(0, Math.round((height - side) / 2));
+
+  const canvas = document.createElement('canvas');
+  canvas.width = size;
+  canvas.height = size;
+  // 必须使用软件（CPU）画布：GPU 画布第一次 toDataURL 需要同步读回，
+  // 实测单张 128px 缩略图会阻塞主线程 80–250 ms，几张卡叠起来就是将近 1 s。
+  const context = canvas.getContext('2d', { willReadFrequently: true });
+  if (!context) throw new Error('canvas unavailable');
+  context.imageSmoothingEnabled = true;
+  context.imageSmoothingQuality = 'high';
+
+  // 用 createImageBitmap 的裁剪 + resize 选项把缩放交给解码器，避免 drawImage
+  // 在主线程上对 4096px 原图做昂贵的重采样；不支持时退回 drawImage 的裁剪重载。
+  let bitmap: ImageBitmap | null = null;
+  try {
+    bitmap = await createImageBitmap(image, sx, sy, side, side, { resizeWidth: size, resizeHeight: size, resizeQuality: 'high' });
+  } catch {
+    bitmap = null;
+  }
+  if (bitmap) {
+    context.drawImage(bitmap, 0, 0, size, size);
+    bitmap.close();
+  } else {
+    context.drawImage(image, sx, sy, side, side, 0, 0, size, size);
+  }
+
+  // 优先 WebP（体积小且支持透明）；浏览器不支持时会自动退回 PNG
+  const webp = canvas.toDataURL('image/webp', 0.82);
+  return webp.startsWith('data:image/webp') ? webp : canvas.toDataURL('image/png');
+}
+
+/**
+ * 把超大头像压成缩略图；非超大 / 非位图 / 失败时原样返回。
+ * 用于导入角色卡、上传头像，避免把整张原图继续写进数据库。
+ */
+export async function shrinkAvatarDataUrl(dataUrl: string | null | undefined, size = AVATAR_STORAGE_SIZE): Promise<string | null> {
+  if (!dataUrl || !isOversizedAvatarUrl(dataUrl)) return dataUrl ?? null;
+  try {
+    return await renderThumbnail(dataUrl, size);
+  } catch {
+    return dataUrl;
+  }
+}
+
+/**
+ * 展示用头像 URL：
+ * - 普通头像直接返回原 URL；
+ * - 超大 data URL 返回缩略图；缩略图还没生成好时返回 null（调用方显示备用头像）。
+ */
+export function useAvatarImageUrl(imageUrl: string | null | undefined): string | null {
+  const oversized = isOversizedAvatarUrl(imageUrl);
+  const displayUrl = useSyncExternalStore(
+    subscribe,
+    () => {
+      if (!imageUrl) return null;
+      if (!oversized) return imageUrl;
+      const entry = cache.get(imageUrl);
+      if (entry?.status === 'ready') return entry.thumb;
+      if (entry?.status === 'original') return imageUrl;
+      return null;
+    },
+    () => null,
+  );
+
+  // 在布局阶段登记「仍在使用」：所有卡片的登记都完成后，被动 effect 才开始
+  // 请求缩略图，避免批量挂载时把尚未登记的条目误当成可淘汰对象。
+  useLayoutEffect(() => {
+    if (!imageUrl || !oversized) return;
+    activeUrls.set(imageUrl, (activeUrls.get(imageUrl) ?? 0) + 1);
+    return () => {
+      const count = activeUrls.get(imageUrl);
+      if (count == null) return;
+      if (count <= 1) activeUrls.delete(imageUrl);
+      else activeUrls.set(imageUrl, count - 1);
+    };
+  }, [imageUrl, oversized]);
+
+  useEffect(() => {
+    if (!imageUrl || !oversized) return;
+    // 命中后移到队尾；被淘汰后再补一次生成请求（displayUrl 也在依赖里）。
+    if (cache.has(imageUrl)) touchCacheEntry(imageUrl);
+    else enqueue(imageUrl);
+  }, [imageUrl, oversized, displayUrl]);
+
+  return displayUrl;
+}

package/src/core/characterBook.ts

@@ -1,4 +1,5 @@
 import type { ChatCompletionTool, NetworkMessage } from '../types/models';
+import { randomId } from './randomId';
 
 export const CHARACTER_BOOK_TOOL_NAME = 'recall_memory';
 
@@ -263,7 +264,7 @@ export function injectCharacterBookToolContext(messages: NetworkMessage[], chara
   const recalled = retrieveCharacterBook(characterBook, messages);
   if (!recalled) return messages;
   const keywords = [...new Set(recalled.entries.flatMap((entry) => entry.matchedKeywords))];
-  const id = `character_book_ctx_${crypto.randomUUID()}`;
+  const id = `character_book_ctx_${randomId()}`;
   return [...messages,
     {
       role: 'assistant',

package/src/core/i18n.ts

@@ -39,8 +39,10 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'control.takeOverFailed': '接管控制权失败，请稍后重试',
 
     // ---- 初始化 ----
+    'init.loading': '正在准备酒馆',
+    'init.loadingHint': '正在加载本地数据…',
     'init.failed': '初始化失败',
-    'init.failedHint': '加载本地数据失败，请确认持久化服务已启动后重试。',
+    'init.failedHint': '加载本地数据失败或超时，请确认持久化服务已启动后重试。',
     'init.retry': '重试',
 
     // ---- 侧边栏 / 导航 ----
@@ -192,6 +194,8 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'settings.yoloMode': 'YOLO 模式',
     'settings.yoloModeDesc': '自动批准工具修改和 Shell 执行，无需逐次确认。仅在信任角色和技能时开启。',
     'settings.genParams': '🎛 生成参数',
+    'settings.genParamsReset': '重置',
+    'settings.genParamsResetTitle': '将生成参数恢复为默认值',
     'settings.tempDesc': '创造性与随机性',
     'settings.topPDesc': '核采样',
     'settings.topKDesc': '候选数量',
@@ -337,9 +341,11 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'workshop.skillBadJson': '（JSON 解析失败）',
 
     // ---- 成就 / 统计 ----
-    'stats.title': '🏆 成就',
+    'stats.title': '成就',
     'stats.sub': '你的成就奖杯会陈列在这里',
     'stats.resetBtn': '重置统计',
+    'stats.resetTitle': '重置生涯统计',
+    'stats.resetDesc': '清除 Token、对话轮次与角色活跃度统计；已解锁的成就奖杯将被保留。',
     'stats.resetConfirm': '确定重置生涯统计？（不会清除已解锁的成就奖杯）',
     'stats.shelfTitle': '🎖️ 奖杯陈列柜',
     'stats.unlocked': '已解锁',
@@ -372,6 +378,8 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'ach.nightOwl.desc': '累计使用 1,000,000 Token',
     'ach.legend.name': '酒馆传奇',
     'ach.legend.desc': '累计使用 100,000,000 Token',
+    'ach.thShareholder.name': 'TH股东',
+    'ach.thShareholder.desc': '5 秒内连续点击首页图标 5 次',
 
     // ---- 成就解锁弹窗 ----
     'achModal.title': '🎉 成就解锁！',
@@ -421,6 +429,7 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'toast.sessionReset': '会话已重置',
     'toast.sessionPinned': '已置顶对话',
     'toast.sessionUnpinned': '已取消置顶',
+    'toast.genParamsReset': '生成参数已恢复为默认值',
     'toast.exportCanceled': '已取消导出',
     'toast.gameplayExported': '游戏已导出',
     'toast.gameplayImported': '已导入游戏「{title}」：新角色 {npc} 个、世界书 {wb}、技能 {tools} 个、对话 {msgs} 条',
@@ -430,6 +439,8 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'toast.mentionRequired': '仅 @ 模式下，请先 @ 一位角色再发送消息',
     'toast.noEndpoint': '请在「模型服务 Provider」中添加并启用一个端点，并选择模型',
     'toast.genFailed': '生成失败: {msg}',
+    'toast.emptyModelResponse': '模型未返回内容。请确认所选模型可用后重试。',
+    'chat.interrupted': '生成已中断，已保留部分内容。',
     'toast.contextCompressionFailed': '上下文压缩失败，将继续使用原始历史: {msg}',
     'toast.rawExported': '已导出原始日志（自动脱敏）',
     'toast.copied': '已复制到剪贴板',
@@ -470,6 +481,7 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
 
     // ---- 工具执行输出（用户可见部分） ----
     'tool.timeout': '请求超时',
+    'tool.networkError': '无法连接到模型服务，请检查网络与 Provider 的 Base URL',
     'tool.diceRoll': '掷骰 {expr}: [{rolls}] = {total}{crit}',
     'tool.diceCrit20': ' 大成功！',
     'tool.diceCrit1': ' 大失败！',
@@ -537,8 +549,10 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'control.takeOverHere': '點擊接管控制權',
     'control.takeOverFailed': '接管控制權失敗，請稍後重試',
 
+    'init.loading': '正在準備酒館',
+    'init.loadingHint': '正在載入本機資料…',
     'init.failed': '初始化失敗',
-    'init.failedHint': '載入本機資料失敗，請確認持久化服務已啟動後重試。',
+    'init.failedHint': '載入本機資料失敗或逾時，請確認持久化服務已啟動後重試。',
     'init.retry': '重試',
 
     'nav.chat': '對話',
@@ -685,6 +699,8 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'settings.yoloMode': 'YOLO 模式',
     'settings.yoloModeDesc': '自動批准工具修改和 Shell 執行，無需逐次確認。僅在信任角色和技能時開啟。',
     'settings.genParams': '🎛 產生參數',
+    'settings.genParamsReset': '重設',
+    'settings.genParamsResetTitle': '將產生參數恢復為預設值',
     'settings.tempDesc': '創造性與隨機性',
     'settings.topPDesc': '核採樣',
     'settings.topKDesc': '候選數量',
@@ -828,9 +844,11 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'workshop.skillNoParams': '（無參數）',
     'workshop.skillBadJson': '（JSON 解析失敗）',
 
-    'stats.title': '🏆 成就',
+    'stats.title': '成就',
     'stats.sub': '你的成就獎盃會陳列在這裡',
     'stats.resetBtn': '重置統計',
+    'stats.resetTitle': '重置生涯統計',
+    'stats.resetDesc': '清除 Token、對話輪次與角色活躍度統計；已解鎖的成就獎盃將被保留。',
     'stats.resetConfirm': '確定重置生涯統計？（不會清除已解鎖的成就獎盃）',
     'stats.shelfTitle': '🎖️ 獎盃陳列櫃',
     'stats.unlocked': '已解鎖',
@@ -862,6 +880,8 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'ach.nightOwl.desc': '累計使用 1,000,000 Token',
     'ach.legend.name': '酒館傳奇',
     'ach.legend.desc': '累計使用 100,000,000 Token',
+    'ach.thShareholder.name': 'TH股東',
+    'ach.thShareholder.desc': '5 秒內連續點擊首頁圖示 5 次',
 
     'achModal.title': '🎉 成就解鎖！',
     'achModal.total': '生涯已累計 {n} Tokens',
@@ -909,6 +929,7 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'toast.sessionReset': '會話已重置',
     'toast.sessionPinned': '已置頂對話',
     'toast.sessionUnpinned': '已取消置頂',
+    'toast.genParamsReset': '產生參數已恢復為預設值',
     'toast.exportCanceled': '已取消匯出',
     'toast.exportFailed': '匯出失敗: {msg}',
     'toast.busy': '正在產生中，請稍候',
@@ -916,6 +937,8 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'toast.mentionRequired': '僅 @ 模式下，請先 @ 一位角色再傳送訊息',
     'toast.noEndpoint': '請在「模型服務 Provider」中新增並啟用一個端點，並選擇模型',
     'toast.genFailed': '產生失敗: {msg}',
+    'toast.emptyModelResponse': '模型未回傳內容。請確認所選模型可用後重試。',
+    'chat.interrupted': '產生已中斷，已保留部分內容。',
     'toast.contextCompressionFailed': '上下文壓縮失敗，將繼續使用原始歷史: {msg}',
     'toast.rawExported': '已匯出原始日誌（自動脫敏）',
     'toast.copied': '已複製到剪貼簿',
@@ -955,6 +978,7 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'toast.canceled': 'CANCELLED: 使用者取消了 {name}',
 
     'tool.timeout': '請求逾時',
+    'tool.networkError': '無法連線到模型服務，請檢查網路與 Provider 的 Base URL',
     'tool.diceRoll': '擲骰 {expr}: [{rolls}] = {total}{crit}',
     'tool.diceCrit20': ' 大成功！',
     'tool.diceCrit1': ' 大失敗！',
@@ -1021,8 +1045,10 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'control.takeOverHere': 'Click to take control',
     'control.takeOverFailed': 'Failed to take control. Please try again.',
 
+    'init.loading': 'Preparing the tavern',
+    'init.loadingHint': 'Loading local data…',
     'init.failed': 'Initialization failed',
-    'init.failedHint': 'Failed to load local data. Make sure the persistence service is running, then try again.',
+    'init.failedHint': 'Loading local data failed or timed out. Make sure the persistence service is running, then try again.',
     'init.retry': 'Retry',
 
     'nav.chat': 'Chat',
@@ -1169,6 +1195,8 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'settings.yoloMode': 'YOLO mode',
     'settings.yoloModeDesc': 'Automatically approve tool changes and Shell commands without asking each time. Only enable for trusted characters and skills.',
     'settings.genParams': '🎛 Generation parameters',
+    'settings.genParamsReset': 'Reset',
+    'settings.genParamsResetTitle': 'Restore generation parameters to their default values',
     'settings.tempDesc': 'Creativity & randomness',
     'settings.topPDesc': 'Nucleus sampling',
     'settings.topKDesc': 'Candidate count',
@@ -1312,9 +1340,11 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'workshop.skillNoParams': '(No parameters)',
     'workshop.skillBadJson': '(Failed to parse JSON)',
 
-    'stats.title': '🏆 Achievements',
+    'stats.title': 'Achievements',
     'stats.sub': 'Your achievement trophies are displayed here',
     'stats.resetBtn': 'Reset stats',
+    'stats.resetTitle': 'Reset career stats',
+    'stats.resetDesc': 'Clear token, conversation, and character activity statistics. Unlocked trophies will be kept.',
     'stats.resetConfirm': 'Reset career stats? (Unlocked trophies won\'t be cleared)',
     'stats.shelfTitle': '🎖️ Trophy Shelf',
     'stats.unlocked': 'Unlocked',
@@ -1346,6 +1376,8 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'ach.nightOwl.desc': 'Cumulatively used 1,000,000 tokens',
     'ach.legend.name': 'Tavern Legend',
     'ach.legend.desc': 'Cumulatively used 100,000,000 tokens',
+    'ach.thShareholder.name': 'TH Shareholder',
+    'ach.thShareholder.desc': 'Clicked the home icon 5 times within 5 seconds',
 
     'achModal.title': '🎉 Achievement unlocked!',
     'achModal.total': 'Lifetime total {n} tokens',
@@ -1391,6 +1423,7 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'toast.sessionReset': 'Conversation reset',
     'toast.sessionPinned': 'Conversation pinned',
     'toast.sessionUnpinned': 'Conversation unpinned',
+    'toast.genParamsReset': 'Generation parameters restored to defaults',
     'toast.exportCanceled': 'Export canceled',
     'toast.gameplayExported': 'Gameplay exported',
     'toast.gameplayImported': 'Imported gameplay "{title}": {npc} new characters, Lorebook {wb}, {tools} skills, {msgs} messages',
@@ -1400,6 +1433,8 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'toast.mentionRequired': 'Mention-only mode requires @ a character before sending',
     'toast.noEndpoint': 'Add and enable an endpoint under "Model Providers" and select a model',
     'toast.genFailed': 'Generation failed: {msg}',
+    'toast.emptyModelResponse': 'The model returned no content. Check that the selected model is available, then try again.',
+    'chat.interrupted': 'Generation interrupted; partial content was kept.',
     'toast.contextCompressionFailed': 'Context compression failed; using the original history: {msg}',
     'toast.rawExported': 'Raw log exported (auto-sanitized)',
     'toast.copied': 'Copied to clipboard',
@@ -1439,6 +1474,7 @@ const MESSAGES: Record<LangKey, Record<string, string>> = {
     'toast.canceled': 'CANCELLED: user canceled {name}',
 
     'tool.timeout': 'Request timed out',
+    'tool.networkError': 'Unable to reach the model service. Check your network and the provider Base URL',
     'tool.diceRoll': '{expr}: [{rolls}] = {total}{crit}',
     'tool.diceCrit20': ' Critical hit!',
     'tool.diceCrit1': ' Critical fail!',

package/src/core/mobileViewport.ts

@@ -59,6 +59,8 @@ let openTimer = 0;
 let opening = false;
 let openingStart = 0;
 let appliedHeight: number | null = null;
+/** 输入框获得焦点后，键盘展开完成前临时锁住壳层高度。 */
+let focusHeightLock = false;
 /** 是否用显式像素高度控制壳层（不跟随 100%）。 */
 let explicitHeight = false;
 
@@ -71,7 +73,7 @@ function isEdgeAndroid(): boolean {
 }
 
 function usesExplicitHeight(): boolean {
-  return explicitHeight || isEdgeAndroid();
+  return focusHeightLock || explicitHeight || isEdgeAndroid();
 }
 
 function applyHeight(px: number | null): void {
@@ -119,6 +121,7 @@ function reset(): void {
   keyboardOpen = false;
   focused = false;
   keyboardAtLastTouch = false;
+  focusHeightLock = false;
   pendingSmall = null;
   holdBaseHeight = 0;
   // 需要显式像素高度时（Edge Android，或已观察到工具栏延迟归位）按当前高度排版；
@@ -153,6 +156,7 @@ function scheduleCloseSettle(): void {
 
 function closeSettled(height: number): void {
   keyboardOpen = false;
+  focusHeightLock = false;
   focused = false;
   closedHeight = height;
   closedCandidate = height;
@@ -299,6 +303,7 @@ function onResize(): void {
     pendingSmall = null;
     holdBaseHeight = 0;
     keyboardOpen = true;
+    focusHeightLock = false;
     // 键盘高度可能还会二次变化（候选栏/工具栏收起），等一小段再一次性落位，
     // 避免输入框先弹到较高位置、再落回键盘上方。
     opening = true;
@@ -345,14 +350,24 @@ export function initMobileViewport(): void {
   document.addEventListener(
     'focusin',
     (event) => {
-      if (isEditableTarget(event.target)) focused = true;
+      if (!isEditableTarget(event.target)) return;
+      focused = true;
+      // Android 会先让 `dvh` 收缩一帧、随后才派发足够大的 resize 来识别键盘。
+      // 在这段间隙锁住壳层，编辑弹窗不会先缩小下沉再上移。
+      focusHeightLock = isMobileViewport() && !keyboardOpen;
+      if (focusHeightLock) applyHeight(window.innerHeight);
     },
     true,
   );
   document.addEventListener(
     'focusout',
     (event) => {
-      if (isEditableTarget(event.target)) focused = false;
+      if (!isEditableTarget(event.target)) return;
+      focused = false;
+      if (focusHeightLock && !keyboardOpen) {
+        focusHeightLock = false;
+        followViewport(window.innerHeight);
+      }
     },
     true,
   );

package/src/core/openai.ts

@@ -8,7 +8,13 @@ import { fallbackToolCallId } from './turnLoop';
 import { isNetworkLikeError, toProxyUrl } from './proxy';
 import { translate } from './i18n';
 
-const OPENAI_TIMEOUTS = { read: 60_000 };
+/**
+ * 连接超时与读超时分开：
+ * - 连接超时覆盖「还没拿到响应头」的阶段。手机通过局域网打开应用时，Provider
+ *   若只在内网 / 本机可达，直连会一直卡在连接上；这时应该尽快改走同源代理。
+ * - 读超时覆盖「已建立连接、等待下一个数据块」，思考模型首 token 可能很慢。
+ */
+const OPENAI_TIMEOUTS = { connect: 20_000, read: 60_000 };
 
 interface ToolDelta {
   id: string;
@@ -33,6 +39,11 @@ function* urlCandidates(baseUrl: string): Generator<string> {
 // SSE 流式解析器 — 支持 thinking / tool_calls / usage
 // ============================================================
 
+type StreamAttempt =
+  | { status: 'done' }
+  /** 本轮没有收到响应（连接失败 / 连接超时），可以改试下一个候选地址 */
+  | { status: 'retry' };
+
 export async function streamChatCompletions(
   baseUrl: string,
   apiKey: string,
@@ -40,13 +51,17 @@ export async function streamChatCompletions(
   onChunk: (chunk: ChatStreamChunk) => void,
   signal?: AbortSignal
 ): Promise<void> {
-  // 依次尝试：直连 → 同源代理（CORS 被拦截时自动回退）
+  // 依次尝试：直连 → 同源代理（CORS / 内网不可达时自动回退）
   for (const url of urlCandidates(baseUrl)) {
-    const ok = await attemptStream(url, apiKey, request, onChunk, signal);
-    if (ok) return;
-    // 直连失败且是网络层错误（CORS 等）→ 继续尝试下一个候选（代理）
-    // 若是业务错误（HTTP 4xx/5xx、解析失败）则不重试
+    const attempt = await attemptStream(url, apiKey, request, onChunk, signal);
+    if (attempt.status === 'done') return;
+  }
+  // 所有候选都连不上：必须显式报错。否则调用方会拿到一次「空回复」并反复重试。
+  if (signal?.aborted) {
+    onChunk({ type: 'done' });
+    return;
   }
+  onChunk({ type: 'error', message: translate('tool.networkError') });
 }
 
 async function attemptStream(
@@ -55,7 +70,7 @@ async function attemptStream(
   request: ChatCompletionRequest,
   onChunk: (chunk: ChatStreamChunk) => void,
   signal?: AbortSignal
-): Promise<boolean> {
+): Promise<StreamAttempt> {
   const controller = new AbortController();
   const onAbort = () => controller.abort();
   if (signal) {
@@ -63,11 +78,13 @@ async function attemptStream(
     else signal.addEventListener('abort', onAbort);
   }
   let timer: ReturnType<typeof setTimeout> | null = null;
-  const resetReadTimeout = () => {
+  const resetTimeout = (ms: number) => {
     if (timer) clearTimeout(timer);
-    timer = setTimeout(() => controller.abort(), OPENAI_TIMEOUTS.read);
+    timer = setTimeout(() => controller.abort(), ms);
   };
-  resetReadTimeout();
+  /** 是否已经拿到响应头：拿到之后就不再回退代理，避免同一次生成被请求两次 */
+  let responded = false;
+  resetTimeout(OPENAI_TIMEOUTS.connect);
 
   try {
     const resp = await fetch(url, {
@@ -79,6 +96,7 @@ async function attemptStream(
       body: JSON.stringify(request),
       signal: controller.signal,
     });
+    responded = true;
 
     if (!resp.ok) {
       let detail = '';
@@ -89,12 +107,12 @@ async function attemptStream(
         /* ignore */
       }
       onChunk({ type: 'error', message: `HTTP ${resp.status}: ${detail || resp.statusText}` });
-      return true; // 业务性错误，不再重试代理
+      return { status: 'done' }; // 业务性错误，不再重试代理
     }
 
     if (!resp.body) {
       onChunk({ type: 'error', message: 'Response body is empty (streaming not supported?)' });
-      return true;
+      return { status: 'done' };
     }
 
     const reader = resp.body.getReader();
@@ -103,10 +121,11 @@ async function attemptStream(
     // Delta 工具调用按 index 组装
     const toolDeltas = new Map<number, ToolDelta>();
     let buffer = '';
+    resetTimeout(OPENAI_TIMEOUTS.read);
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
-      resetReadTimeout();
+      resetTimeout(OPENAI_TIMEOUTS.read);
       buffer += decoder.decode(value, { stream: true });
 
       // 按行切分 SSE
@@ -134,22 +153,25 @@ async function attemptStream(
     // 收尾：补发未完成的工具调用
     emitFinalToolCalls(toolDeltas, onChunk);
     onChunk({ type: 'done' });
-    return true;
+    return { status: 'done' };
   } catch (e) {
     if (signal?.aborted) {
       onChunk({ type: 'done' });
-      return true;
+      return { status: 'done' };
     }
     if ((e as Error).name === 'AbortError' || (e as Error).name === 'TimeoutError') {
+      // 连接阶段就超时（手机直连内网地址不可达）→ 交给外层换代理再试；
+      // 已经收到响应头则属于读超时，重试会造成重复生成。
+      if (!responded) return { status: 'retry' };
       onChunk({ type: 'error', message: translate('tool.timeout') });
-      return true;
+      return { status: 'done' };
     }
-    // 网络层错误：若还有代理候选则返回 false 让外层重试；否则报错
+    // 网络层错误：若还没拿到响应则换下一个候选（代理），否则按错误上报
     if (isNetworkLikeError(e)) {
-      return false;
+      if (!responded) return { status: 'retry' };
     }
     onChunk({ type: 'error', message: (e as Error).message || String(e) });
-    return true;
+    return { status: 'done' };
   } finally {
     if (timer) clearTimeout(timer);
     if (signal) signal.removeEventListener('abort', onAbort);