dsh-vision-router 2.1.2 → 2.1.3

package/lib/client-presentation-boundary-main.js

@@ -488,6 +488,465 @@ export const CLIENT_PRESENTATION_PRELUDE = String.raw`(function(){
     }
   }
 
+  // #138 Windows clipboard compatibility: desktop clipboards may expose an
+  // image as BMP/empty MIME, or may declare a supported MIME that disagrees with
+  // the actual bytes (for example .png + image/png carrying JPEG bytes). DSH
+  // validates the declaration before/while creating the draft, and its local
+  // attachment store rejects declaration/content mismatches. Inspect image-like
+  // clipboard files by magic bytes before Lexical's CRITICAL paste handler sees
+  // them; canonical files keep the original File object and are never re-encoded.
+  function installClipboardImagePasteCompat(ctx) {
+    if (!ctx || typeof ctx.effect !== 'function') return;
+    ctx.effect(function() {
+      var doc = window.document;
+      if (!doc || typeof doc.addEventListener !== 'function') return function(){};
+      if (
+        typeof window.DataTransfer !== 'function' ||
+        typeof window.ClipboardEvent !== 'function' ||
+        typeof window.File !== 'function' ||
+        typeof WeakSet !== 'function'
+      ) return function(){};
+
+      var replayed = new WeakSet();
+      var supported = {
+        'image/png': true,
+        'image/jpeg': true,
+        'image/webp': true,
+        'image/gif': true
+      };
+      var bitmapTypes = {
+        'image/bmp': true,
+        'image/x-bmp': true,
+        'image/x-ms-bmp': true
+      };
+
+      function mediaType(value) {
+        return typeof value === 'string' ? value.trim().toLowerCase() : '';
+      }
+
+      function imageLikeName(value) {
+        return typeof value === 'string' && /\.(?:png|jpe?g|webp|gif|bmp|dib)$/i.test(value.trim());
+      }
+
+      function needsInspection(file) {
+        if (!file) return false;
+        var type = mediaType(file.type);
+        return type === '' || type.indexOf('image/') === 0 || imageLikeName(file.name);
+      }
+
+      var normalizedBitmapFiles = new WeakSet();
+      var maxExactDedupeBytes = 8 * 1024 * 1024;
+      var maxVisualDedupeSourceBytes = 16 * 1024 * 1024;
+      var maxVisualDedupeDimension = 4096;
+      var maxVisualDedupePixels = 9000000;
+      var visualDedupeTile = 256;
+
+      function supportedImage(file) {
+        return !!file && supported[mediaType(file.type)] === true;
+      }
+
+      function syntheticClipboardName(name) {
+        var value = typeof name === 'string' ? name.trim() : '';
+        if (value === '') return true;
+        return /^(?:image|clipboard)(?:[ _-]?\d+)?\.(?:png|jpe?g|webp|gif)$/i.test(value);
+      }
+
+      function syntheticClipboardFile(file) {
+        return !!file && (normalizedBitmapFiles.has(file) || syntheticClipboardName(file.name));
+      }
+
+      function hasDedupeSignal(files) {
+        var images = files.filter(supportedImage);
+        for (var i = 0; i < images.length; i += 1) {
+          for (var j = i + 1; j < images.length; j += 1) {
+            var left = images[i];
+            var right = images[j];
+            if (
+              (Number.isFinite(left.size) && left.size > 0 && left.size === right.size) ||
+              (mediaType(left.type) === mediaType(right.type) &&
+                (syntheticClipboardFile(left) || syntheticClipboardFile(right)))
+            ) return true;
+          }
+        }
+        return false;
+      }
+
+      function bytesOf(file) {
+        if (!file || typeof file.arrayBuffer !== 'function') return Promise.resolve(undefined);
+        try {
+          return Promise.resolve(file.arrayBuffer()).then(function(buffer) {
+            return new Uint8Array(buffer);
+          }, function(){ return undefined; });
+        } catch (_) {
+          return Promise.resolve(undefined);
+        }
+      }
+
+      function sameBytes(left, right) {
+        if (
+          !left || !right ||
+          !Number.isFinite(left.size) || left.size <= 0 || left.size !== right.size ||
+          left.size > maxExactDedupeBytes
+        ) return Promise.resolve(false);
+        return Promise.all([bytesOf(left), bytesOf(right)]).then(function(values) {
+          var a = values[0];
+          var b = values[1];
+          if (!a || !b || a.length !== b.length) return false;
+          for (var i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
+          return true;
+        }, function(){ return false; });
+      }
+
+      function visualPairAllowed(left, right) {
+        if (!left || !right) return false;
+        if (mediaType(left.type) !== 'image/png' || mediaType(right.type) !== 'image/png') return false;
+        if (!(syntheticClipboardFile(left) || syntheticClipboardFile(right))) return false;
+        return Number.isFinite(left.size) && left.size > 0 && left.size <= maxVisualDedupeSourceBytes &&
+          Number.isFinite(right.size) && right.size > 0 && right.size <= maxVisualDedupeSourceBytes;
+      }
+
+      function closeBitmap(bitmap) {
+        try { if (bitmap && typeof bitmap.close === 'function') bitmap.close(); } catch (_) {}
+      }
+
+      function visualInfoAllowed(leftInfo, rightInfo) {
+        if (!leftInfo || !rightInfo || leftInfo.type !== 'image/png' || rightInfo.type !== 'image/png') return false;
+        var width = leftInfo.width;
+        var height = leftInfo.height;
+        return Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0 &&
+          width === rightInfo.width && height === rightInfo.height &&
+          width <= maxVisualDedupeDimension && height <= maxVisualDedupeDimension &&
+          width * height <= maxVisualDedupePixels;
+      }
+
+      function bitmapPixelsMatch(left, right) {
+        if (!visualPairAllowed(left, right) || typeof window.createImageBitmap !== 'function') return Promise.resolve(false);
+        return Promise.all([headType(left), headType(right)]).then(function(infos) {
+          if (!visualInfoAllowed(infos[0], infos[1])) return false;
+          return Promise.resolve(window.createImageBitmap(left)).then(function(leftBitmap) {
+          return Promise.resolve(window.createImageBitmap(right)).then(function(rightBitmap) {
+            try {
+              var width = leftBitmap && leftBitmap.width;
+              var height = leftBitmap && leftBitmap.height;
+              if (
+                !Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0 ||
+                width !== rightBitmap.width || height !== rightBitmap.height ||
+                width > maxVisualDedupeDimension || height > maxVisualDedupeDimension ||
+                width * height > maxVisualDedupePixels
+              ) return false;
+              var canvas = doc.createElement('canvas');
+              var context = canvas.getContext && canvas.getContext('2d', { willReadFrequently: true });
+              if (!context || typeof context.drawImage !== 'function' || typeof context.getImageData !== 'function') return false;
+              for (var y = 0; y < height; y += visualDedupeTile) {
+                for (var x = 0; x < width; x += visualDedupeTile) {
+                  var tileWidth = Math.min(visualDedupeTile, width - x);
+                  var tileHeight = Math.min(visualDedupeTile, height - y);
+                  canvas.width = tileWidth;
+                  canvas.height = tileHeight;
+                  context.drawImage(leftBitmap, x, y, tileWidth, tileHeight, 0, 0, tileWidth, tileHeight);
+                  var leftPixels = context.getImageData(0, 0, tileWidth, tileHeight).data;
+                  context.drawImage(rightBitmap, x, y, tileWidth, tileHeight, 0, 0, tileWidth, tileHeight);
+                  var rightPixels = context.getImageData(0, 0, tileWidth, tileHeight).data;
+                  if (!leftPixels || !rightPixels || leftPixels.length !== rightPixels.length) return false;
+                  for (var i = 0; i < leftPixels.length; i += 1) {
+                    if (leftPixels[i] !== rightPixels[i]) return false;
+                  }
+                }
+              }
+              return true;
+            } catch (_) {
+              return false;
+            } finally {
+              closeBitmap(leftBitmap);
+              closeBitmap(rightBitmap);
+            }
+          }, function() {
+            closeBitmap(leftBitmap);
+            return false;
+          });
+          }, function(){ return false; });
+        }, function(){ return false; });
+      }
+
+      function duplicatePair(left, right) {
+        if (!supportedImage(left) || !supportedImage(right)) return Promise.resolve(false);
+        return sameBytes(left, right).then(function(exact) {
+          return exact ? true : bitmapPixelsMatch(left, right);
+        }, function(){ return false; });
+      }
+
+      function preferredDuplicate(left, right) {
+        if (syntheticClipboardFile(left) && !syntheticClipboardFile(right)) return right;
+        return left;
+      }
+
+      function dedupeBatch(files) {
+        if (!hasDedupeSignal(files)) return Promise.resolve(files);
+        var kept = [];
+        var chain = Promise.resolve();
+        files.forEach(function(file) {
+          chain = chain.then(function() {
+            var index = 0;
+            function compareNext() {
+              if (index >= kept.length) {
+                kept.push(file);
+                return Promise.resolve();
+              }
+              var current = index;
+              index += 1;
+              return duplicatePair(kept[current], file).then(function(duplicate) {
+                if (!duplicate) return compareNext();
+                kept[current] = preferredDuplicate(kept[current], file);
+                return undefined;
+              }, function(){ return compareNext(); });
+            }
+            return compareNext();
+          });
+        });
+        return chain.then(function(){ return kept; }, function(){ return files; });
+      }
+
+      function composerEditable(target) {
+        var element = target && target.nodeType === 1
+          ? target
+          : target && target.parentElement;
+        if (!element || typeof element.closest !== 'function') return null;
+        var editable = element.closest('[data-composer-input]');
+        if (!editable || typeof editable.closest !== 'function') return null;
+        return editable.closest('[data-composer-card]') ? editable : null;
+      }
+
+      function snapshotText(data) {
+        var entries = [];
+        var types = data && data.types ? Array.from(data.types) : [];
+        types.forEach(function(type) {
+          if (type === 'Files') return;
+          try {
+            var value = data.getData(type);
+            if (typeof value === 'string' && value !== '') entries.push([type, value]);
+          } catch (_) {}
+        });
+        return entries;
+      }
+
+      var maxBitmapSourceBytes = 64 * 1024 * 1024;
+      var maxBitmapDimension = 10000;
+      var maxBitmapPixels = 100000000;
+
+      function sniffImageInfo(bytes) {
+        if (!bytes || bytes.length < 2) return undefined;
+        if (
+          bytes.length >= 8 &&
+          bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47 &&
+          bytes[4] === 0x0d && bytes[5] === 0x0a && bytes[6] === 0x1a && bytes[7] === 0x0a
+        ) {
+          if (bytes.length < 24 || typeof DataView !== 'function') return { type: 'image/png' };
+          try {
+            var pngView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+            return {
+              type: 'image/png',
+              width: pngView.getUint32(16, false),
+              height: pngView.getUint32(20, false)
+            };
+          } catch (_) {
+            return { type: 'image/png' };
+          }
+        }
+        if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return { type: 'image/jpeg' };
+        if (
+          bytes.length >= 6 && bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46 &&
+          bytes[3] === 0x38 && (bytes[4] === 0x37 || bytes[4] === 0x39) && bytes[5] === 0x61
+) return { type: 'image/gif' };
+        if (
+          bytes.length >= 12 && bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46 &&
+          bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50
+) return { type: 'image/webp' };
+        if (bytes[0] === 0x42 && bytes[1] === 0x4d) {
+          if (bytes.length < 26 || typeof DataView !== 'function') return { type: 'image/bmp' };
+          try {
+            var view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+            var dibSize = bytes.length >= 18 ? view.getUint32(14, true) : 0;
+            if (dibSize < 40) return { type: 'image/bmp' };
+            return {
+              type: 'image/bmp',
+              width: Math.abs(view.getInt32(18, true)),
+              height: Math.abs(view.getInt32(22, true))
+            };
+          } catch (_) {
+            return { type: 'image/bmp' };
+          }
+        }
+        return undefined;
+      }
+
+      function headType(file) {
+        try {
+          var blob = typeof file.slice === 'function' ? file.slice(0, 32) : file;
+          if (!blob || typeof blob.arrayBuffer !== 'function') return Promise.resolve(undefined);
+          return Promise.resolve(blob.arrayBuffer()).then(function(buffer) {
+            return sniffImageInfo(new Uint8Array(buffer));
+          }, function(){ return undefined; });
+        } catch (_) {
+          return Promise.resolve(undefined);
+        }
+      }
+
+      function fileNameFor(type, original) {
+        var name = typeof original === 'string' ? original : '';
+        var suffix = type === 'image/png' ? '.png'
+          : type === 'image/jpeg' ? '.jpg'
+          : type === 'image/gif' ? '.gif'
+          : type === 'image/webp' ? '.webp'
+          : '';
+        if (!name) return suffix ? 'clipboard' + suffix : 'clipboard-image';
+        if (!suffix) return name;
+        return /\.(?:png|jpe?g|webp|gif|bmp|dib)$/i.test(name)
+          ? name.replace(/\.(?:png|jpe?g|webp|gif|bmp|dib)$/i, suffix)
+          : name;
+      }
+
+      function retypeFile(file, type) {
+        return new window.File([file], fileNameFor(type, file && file.name), {
+          type: type,
+          lastModified: file && Number.isFinite(file.lastModified) ? file.lastModified : Date.now()
+        });
+      }
+
+      function bitmapDecodeAllowed(file, info) {
+        if (!file || !info) return false;
+        if (!Number.isFinite(file.size) || file.size <= 0 || file.size > maxBitmapSourceBytes) return false;
+        if (!Number.isFinite(info.width) || !Number.isFinite(info.height) || info.width <= 0 || info.height <= 0) return false;
+        if (info.width > maxBitmapDimension || info.height > maxBitmapDimension) return false;
+        return info.width * info.height <= maxBitmapPixels;
+      }
+
+      function bitmapToPng(file) {
+        if (typeof window.createImageBitmap !== 'function') return Promise.reject(new Error('createImageBitmap unavailable'));
+        return Promise.resolve(window.createImageBitmap(file)).then(function(bitmap) {
+          return new Promise(function(resolve, reject) {
+            var close = function() {
+              try { if (bitmap && typeof bitmap.close === 'function') bitmap.close(); } catch (_) {}
+            };
+            try {
+              var canvas = doc.createElement('canvas');
+              canvas.width = bitmap.width;
+              canvas.height = bitmap.height;
+              var context = canvas.getContext && canvas.getContext('2d');
+              if (!context || typeof context.drawImage !== 'function' || typeof canvas.toBlob !== 'function') {
+                close();
+                reject(new Error('canvas PNG conversion unavailable'));
+                return;
+              }
+              context.drawImage(bitmap, 0, 0);
+              canvas.toBlob(function(blob) {
+                close();
+                if (!blob) {
+                  reject(new Error('canvas PNG conversion failed'));
+                  return;
+                }
+                try {
+                  var normalized = new window.File([blob], fileNameFor('image/png', file && file.name), {
+                    type: 'image/png',
+                    lastModified: file && Number.isFinite(file.lastModified) ? file.lastModified : Date.now()
+                  });
+                  normalizedBitmapFiles.add(normalized);
+                  resolve(normalized);
+                } catch (error) {
+                  reject(error);
+                }
+              }, 'image/png');
+            } catch (error) {
+              close();
+              reject(error);
+            }
+          });
+        });
+      }
+
+      function normalizeFile(file) {
+        return headType(file).then(function(info) {
+          var detected = info && info.type;
+          if (detected && supported[detected]) {
+            return mediaType(file && file.type) === detected ? file : retypeFile(file, detected);
+          }
+          if (detected === 'image/bmp' && bitmapDecodeAllowed(file, info)) return bitmapToPng(file);
+          return file;
+        }, function(){ return file; });
+      }
+
+      function replayEvent(files, textEntries) {
+        try {
+          var transfer = new window.DataTransfer();
+          if (!transfer.items || typeof transfer.items.add !== 'function') return null;
+          files.forEach(function(file){ transfer.items.add(file); });
+          textEntries.forEach(function(entry){ transfer.setData(entry[0], entry[1]); });
+          var event = new window.ClipboardEvent('paste', {
+            clipboardData: transfer,
+            bubbles: true,
+            cancelable: true,
+            composed: true
+          });
+          return event && event.clipboardData === transfer ? event : null;
+        } catch (_) {
+          return null;
+        }
+      }
+
+      function dispatchReplay(target, preferred, fallback) {
+        var event = preferred || fallback;
+        if (!event || !target || typeof target.dispatchEvent !== 'function') return;
+        replayed.add(event);
+        try {
+          target.dispatchEvent(event);
+        } catch (_) {
+          if (fallback && fallback !== event) {
+            replayed.add(fallback);
+            try { target.dispatchEvent(fallback); } catch (_) {}
+          }
+        }
+      }
+
+      function onPaste(event) {
+        if (!event || replayed.has(event)) return;
+        var target = composerEditable(event.target);
+        if (!target) return;
+        var data = event.clipboardData;
+        if (!data || !data.items) return;
+        var files = Array.from(data.items)
+          .filter(function(item){ return item && item.kind === 'file'; })
+          .map(function(item){ try { return item.getAsFile(); } catch (_) { return null; } })
+          .filter(function(file){ return !!file; });
+        if (!files.some(needsInspection) && !hasDedupeSignal(files)) return;
+
+        // Snapshot every string flavor while the trusted paste event still owns
+        // a readable clipboard data store. Build a known-good fallback replay
+        // before canceling the original event so conversion failure never eats
+        // the user's text or files.
+        var textEntries = snapshotText(data);
+        var fallback = replayEvent(files, textEntries);
+        if (!fallback) return;
+
+        if (typeof event.preventDefault === 'function') event.preventDefault();
+        if (typeof event.stopImmediatePropagation === 'function') event.stopImmediatePropagation();
+
+        Promise.all(files.map(function(file){
+          return needsInspection(file)
+            ? normalizeFile(file).catch(function(){ return file; })
+            : Promise.resolve(file);
+        })).then(function(normalized) {
+          return dedupeBatch(normalized).then(function(deduped) {
+            dispatchReplay(target, replayEvent(deduped, textEntries), fallback);
+          });
+        }, function() {
+          dispatchReplay(target, fallback, null);
+        });
+      }
+
+      doc.addEventListener('paste', onPaste, true);
+      return function(){ doc.removeEventListener('paste', onPaste, true); };
+    }, 'vision-router: clipboard image paste normalization');
+  }
+
   function installVisionModeToggle(ctx, React, primitives) {
     if (!ctx || typeof ctx.inject !== 'function' || !React) return;
     var zh = {
@@ -550,7 +1009,19 @@ export const CLIENT_PRESENTATION_PRELUDE = String.raw`(function(){
 
     var settings = bindVisionModeSettings(ctx);
     var unavailableSettingsState = { value: undefined };
-    ctx.inject(['slots', 'modelDirectories'], function(scope) {
+    ctx.inject(['slots', 'modelDirectories', 'sessions', 'remote'], function(scope) {
+      // Cold directoryFor calls use the caller's Cordis context, including its
+      // remote.session declaration. Probe only once modelDirectories is ready;
+      // older Hosts must not acquire a hard dependency on the alpha namespace.
+      var session;
+      try {
+        session = typeof scope.get === 'function' ? scope.get('remote.session') : undefined;
+      } catch (_) {}
+      if (session) scope.inject(['remote.session'], installToggle);
+      else installToggle(scope);
+    });
+
+    function installToggle(scope) {
       var models;
       try {
         models = scope.modelDirectories || (typeof scope.get === 'function' ? scope.get('modelDirectories') : undefined);
@@ -724,7 +1195,7 @@ export const CLIENT_PRESENTATION_PRELUDE = String.raw`(function(){
           }, VisionModeToggle);
         });
       }, 'vision-router: composer vision mode toggle');
-    });
+    }
   }
 
   function decorateVisionRouterPlugin(plugin, React, primitives) {
@@ -736,6 +1207,11 @@ export const CLIENT_PRESENTATION_PRELUDE = String.raw`(function(){
       var args = Array.prototype.slice.call(arguments);
       args[0] = decoratedCtx;
       var result = originalApply.apply(this, args);
+      try {
+        installClipboardImagePasteCompat(decoratedCtx);
+      } catch (error) {
+        try { console.warn('vision-router: failed to install clipboard image paste compatibility', error); } catch (_) {}
+      }
       try {
         installVisionModeToggle(decoratedCtx, React, primitives);
       } catch (error) {

package/lib/client.js

@@ -218,7 +218,7 @@ window.__ModuleLoader__.load({
         '用于兼容旧版行为，一般无需开启；开启后只使用上方识图模型链中的后端。',
       hintReverseRouting: '仅在「整轮交给视觉模型」开启时生效；纯文字消息继续交给聊天模型处理。',
       hintTool: '允许聊天模型按需查看、定位、裁剪和比较图片。推荐保持开启。',
-      hintStructuredVisionBootstrap: '默认关闭。开启后，每个图片任务会先做一次不读取具体任务目标的结构化预识别，再由聊天模型根据原问题至少追加一次验证或深挖识图调用（1+x，x≥1）。启用的 Ollama / LM Studio 会和其他视觉后端一样参与这条识图链，不需要另开「即时识图」。准确性更高，但会增加至少一次视觉调用；若后续需要 OCR，自动模式会优先使用视觉模型。需保持「识图工具」开启。',
+      hintStructuredVisionBootstrap: '默认关闭。开启后，每个图片任务会先做一次不读取具体任务目标的结构化预识别，再由聊天模型根据原问题至少追加一次验证或深挖识图调用（1+x，x≥1）。启用的 Ollama / LM Studio 会和其他视觉后端一样参与这条识图链，不需要另开「即时识图」。准确性更高，但会增加至少一次视觉调用；若后续需要 OCR，engine=auto 仍会先尝试本地 Tesseract，失败或空结果再回退视觉模型；结构化模式不会改变这一顺序。需保持「识图工具」开启。',
       hintAutoWrapProviders: '自动为已启用的聊天模型创建带「+ 自动识图」的版本。原模型不受影响，推荐保持开启。',
       hintRewriteImages: '避免把无法读取的原始图片直接发送给纯文字模型。推荐保持开启。',
       hintDownscale: '超过像素预算的图片先缩放再送视觉模型，降低延迟与成本；默认开启。',
@@ -260,7 +260,7 @@ window.__ModuleLoader__.load({
       depthCapValueLabel: '最多深挖次数',
       depthCapInvalid: '请输入 1–100 之间的整数。',
       numHintTimeoutMs: '单个视觉请求超时；默认 120000。',
-      numHintVisionTaskTimeoutMs: '一次识图任务（含全部 provider、回退与重试）共享的总时限；默认 45000。认证失败/限流会立即熔断对应后端。',
+      numHintVisionTaskTimeoutMs: '一次识图任务（含全部 provider、回退与重试）共享的总时限；默认 120000。认证失败/限流会立即熔断对应后端。',
       numHintOcrTimeoutMs: '一次 OCR 任务的总时限；本地 tesseract 最多用 12 秒，视觉模型回退只用剩余部分；默认 30000。',
       numHintDownscaleMaxPixels: '约 8MP = 8000000；超过的图先缩放再送视觉模型。',
       numHintCacheTtlSeconds: '视觉答案缓存有效期；0 = 永久；默认 3600。',
@@ -493,7 +493,7 @@ window.__ModuleLoader__.load({
         'only the vision models configured above participate.',
       hintReverseRouting: 'Only applies when whole-turn vision routing is enabled; plain text messages continue to use the chat model.',
       hintTool: 'Lets the chat model inspect, locate, crop, and compare images as needed. Recommended on.',
-      hintStructuredVisionBootstrap: 'Off by default. Each image task first gets one task-independent structured visual baseline with no task goal passed into the pre-scan, then the chat model must make at least one evidence or deepening vision call for the original request (1+x, x>=1). Enabled Ollama / LM Studio backends participate in this same vision chain; there is no separate instant-recognition switch. This improves evidence quality but adds at least one visual call. If OCR is needed, auto mode prefers vision-model OCR. Keep Vision tools enabled.',
+      hintStructuredVisionBootstrap: 'Off by default. Each image task first gets one task-independent structured visual baseline with no task goal passed into the pre-scan, then the chat model must make at least one evidence or deepening vision call for the original request (1+x, x>=1). Enabled Ollama / LM Studio backends participate in this same vision chain; there is no separate instant-recognition switch. This improves evidence quality but adds at least one visual call. If OCR is needed, engine=auto still tries local Tesseract first and falls back to the vision model only when local OCR fails or returns no text; structured mode does not change this order. Keep Vision tools enabled.',
       hintAutoWrapProviders: 'Automatically creates a “+ Auto Vision” version of enabled chat models. Original model groups stay unchanged. Recommended on.',
       hintRewriteImages: 'Prevents raw image content from being sent to a text-only model that cannot read it. Recommended on.',
       hintDownscale: 'Images beyond the pixel budget are resized before the vision call, cutting latency and cost; on by default.',
@@ -537,7 +537,7 @@ window.__ModuleLoader__.load({
       depthCapValueLabel: 'Maximum deep-dive calls',
       depthCapInvalid: 'Enter an integer from 1 to 100.',
       numHintTimeoutMs: 'Per vision-call deadline; default 120000.',
-      numHintVisionTaskTimeoutMs: 'One vision task (all providers, fallbacks and retries) shares this wall-clock budget; default 45000. Auth failures and rate limits trip their backend immediately.',
+      numHintVisionTaskTimeoutMs: 'One vision task (all providers, fallbacks and retries) shares this wall-clock budget; default 120000. Auth failures and rate limits trip their backend immediately.',
       numHintOcrTimeoutMs: 'Total budget for one OCR task: tesseract gets at most 12s, the vision fallback only the remainder; default 30000.',
       numHintDownscaleMaxPixels: 'About 8MP = 8000000; larger images are resized before the vision call.',
       numHintCacheTtlSeconds: 'Vision answer cache lifetime; 0 = forever; default 3600.',

package/lib/depth-guidance.js

@@ -49,15 +49,15 @@ function effectiveMaxCalls(explicit) {
 
 const SCENE_GUIDANCE = Object.freeze({
   zh: Object.assign(Object.create(null), {
-    code: '检测到代码内容。代码必须逐字转写，建议分区域转写 + 语义确认，避免概括。',
+    code: '检测到代码内容。按用户问题决定证据：只有当结论依赖可执行或逐字代码时才需要逐字保真；仅问语言、结构或语义时可直接做针对性语义复核。',
     document: '检测到文档内容。语义优先；仅当需要逐字引用（长文档/合同/表单）时才用 OCR。',
-    ui: '检测到界面内容。建议元素清单（detect）+ 关键元素定位（ground）。',
+    ui: '检测到界面内容。按用户问题选择最小必要证据：语义复核、元素盘点或精确定位均可，不固定组合工具。',
     chat: '检测到聊天截图。关注气泡顺序与关键信息提取。',
   }),
   en: Object.assign(Object.create(null), {
-    code: 'Code content detected. Transcribe code verbatim; use region-by-region transcription plus semantic verification instead of summarizing it.',
+    code: 'Code content detected. Let the user question determine the evidence: require verbatim fidelity only when the conclusion depends on executable or text-exact code; language, structure, or semantic questions can use targeted semantic verification.',
     document: 'Document content detected. Prefer semantic understanding; use OCR only when verbatim quotation is required, such as for long documents, contracts, or forms.',
-    ui: 'UI content detected. Prefer an element inventory (detect) plus grounding of the important elements (ground).',
+    ui: 'UI content detected. Choose the smallest evidence needed for the user question: semantic verification, element inventory, or precise localization; do not require a fixed tool combination.',
     chat: 'Chat screenshot detected. Preserve message-bubble order and extract the important information.',
   }),
 })

package/lib/local-vision-stabilizer.js

@@ -76,7 +76,7 @@ export function installLocalVisionStabilizer(ctx, config = {}, core) {
       1000,
       Math.min(
         positive(value.timeoutMs, 120000),
-        positive(value.visionTaskTimeoutMs, 45000),
+        positive(value.visionTaskTimeoutMs, 120000),
       ),
     )
 

package/lib/mixed-router.js

@@ -19,22 +19,22 @@ void UI_SIGNAL_TYPES
 
 const BRANCH_GUIDANCE = Object.freeze({
   zh: new Map([
-    ['document:code', '逐字转写（代码可执行性例外）'],
+    ['document:code', '仅当任务依赖可执行或逐字代码时才做逐字转写；否则按语义问题查证'],
     ['document:form', '语义优先，逐字字段名/值确需引用时用 OCR'],
     ['document:table', '结构提取优先，数字/金额逐字（表格 OCR 专精场景）'],
     ['document:', '语义优先；仅当需要逐字引用（长文档/合同/表单）时才用 OCR'],
-    ['ui:', 'detect / ground 优先（元素清单与像素定位）'],
-    ['code:', '逐字转写（可执行性例外）'],
+    ['ui:', '按问题需要选择语义复核、元素盘点或精确定位，不固定工具组合'],
+    ['code:', '仅当任务依赖可执行或逐字代码时才要求逐字保真；否则按语义问题查证'],
     ['table:', '结构提取优先，数字/金额逐字'],
     ['_default', '放行（模型自由选择识别方式）'],
   ]),
   en: new Map([
-    ['document:code', 'transcribe verbatim (code executability requires text-exact evidence)'],
+    ['document:code', 'use verbatim transcription only when the task depends on executable or text-exact code; otherwise verify the semantic question directly'],
     ['document:form', 'prefer semantic understanding; use OCR when exact field names or values must be quoted'],
     ['document:table', 'prefer structural extraction; preserve numbers and amounts exactly (table OCR is a specialized case)'],
     ['document:', 'prefer semantic understanding; use OCR only when verbatim quotation is required for long documents, contracts, or forms'],
-    ['ui:', 'prefer detect / ground for element inventory and pixel localization'],
-    ['code:', 'transcribe verbatim (executability requires text-exact evidence)'],
+    ['ui:', 'choose semantic verification, element inventory, or precise localization according to the question; do not require a fixed tool combination'],
+    ['code:', 'require verbatim fidelity only when the task depends on executable or text-exact code; otherwise verify the semantic question directly'],
     ['table:', 'prefer structural extraction and preserve numbers/amounts exactly'],
     ['_default', 'allow the model to choose the recognition method freely'],
   ]),
@@ -137,7 +137,7 @@ export function renderMixedGuidance(plan, _depth, locale) {
   })
   const kinds = branches.map((branch) => branch.kind).join(' + ')
   const header = language === 'en'
-    ? `Mixed content detected (${kinds}). To avoid omissions or misclassification, verify each branch separately as needed before answering; do not reuse one branch's recognition method blindly for another branch.`
-    : `检测到混合内容（${kinds}）。为避免漏判/错判（精度优化），请按需分别验证各分支后再作答；分支之间不要盲目混用识别方式。`
+    ? `Mixed content detected (${kinds}). Focus on the branch or branches relevant to the user question. If the answer depends on more than one branch, verify those branches separately as needed; do not reuse one branch's recognition method blindly for another branch.`
+    : `检测到混合内容（${kinds}）。只关注与用户问题相关的分支；如果答案确实依赖多个分支，再按需分别验证这些分支。分支之间不要盲目混用识别方式。`
   return `${header}\n${lines.join('\n')}`
 }