dsh-vision-router 3.0.2 → 3.0.4

package/docs/v2-capability-routing.md

@@ -73,13 +73,28 @@ plan, revoked Auto authority, or planner failure falls back to the current
 configured order. The temporary Auto order is isolated to one visual-tool call
 with `AsyncLocalStorage` and is restored automatically afterward.
 
-Host text-only metadata is advisory for a user-selected generative model. It is
-not treated as proof that the model cannot inspect images. **Test Vision** always
-tries the exact current dropdown selection when its live adapter can be invoked.
-If the user has explicitly enabled `backgroundBenchmarking`, eligible configured
-models are also actually measured within that cost scope even when Host metadata
-currently labels them text-only. The measured result, rather than the Host label,
-is the capability evidence used by Auto.
+Host text-only metadata is advisory for *selection* of a generative backend,
+not proof of the endpoint's real image capability. It is not, however, advisory
+to DSH's request projection: an explicit text-only declaration causes DSH to
+replace image pixels with text placeholders before the adapter is invoked.
+Vision Router bypasses that projection only for positively identified HTTP OpenAI
+Chat Completions bridges. For Responses API, WebSocket, RPC and other native protocols, a genuinely
+image-capable model must have Host image input declared; otherwise a visual
+request cannot safely reach its registered adapter. Where available, use
+**Settings → Models → provider editor → Customized settings → Model options →
+Input types → Image**, then save and reload the model configuration. This model
+editor control is documented in DSH
+[0.1.7-rc.1](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.1.7-rc.1/packages/client/ui-settings-models/README.md)
+and [0.2.0-rc.2](https://github.com/deepseek-ai/deepseek-harness/blob/dsh-v0.2.0-rc.2/packages/client/ui-settings-models/README.md).
+For older Hosts without this control, set the provider-specific model field:
+`llm-pi-ai` uses `input: [text, image]`, while `llm-deepseek` uses
+`inputModalities: [text, image]`. Only declare image input for endpoints that
+actually accept image content. Unknown modalities still use the registered
+adapter first. **Test Vision** targets the exact dropdown model,
+but a text-only Host declaration without a safe bridge may yield an image-input
+failure rather than a valid visual measurement. Explicitly authorized background
+benchmarking has the same delivery constraint; only successful pixel-grounded
+measurements count as capability evidence for Auto.
 
 Structural non-generative exclusions remain hard boundaries: explicit measurement
 authority never turns an endpoint that cannot be invoked as a generative model
@@ -101,8 +116,9 @@ Auto-routing control.
   requests.
 
 A Host text-only label is shown as an advisory, not as a separate product mode.
-Quick/Full Benchmark may still send generated test images to verify the model
-when the user explicitly starts the Benchmark. The implementation may carry an
+Quick/Full Benchmark prepares generated test images when the user explicitly
+starts the Benchmark, but delivery still depends on the Host's model modalities
+or a verified compatible bridge. The implementation may carry an
 internal force flag for compatibility with older service guards, but users do
 not need to reason about a separate “Force Verify” workflow.
 

package/lib/adapter-update-coalescer.js

@@ -1,7 +1,6 @@
 const wrappedContexts = new WeakMap()
 const wrappedLlmServices = new WeakMap()
-const preparedAdapterCompat = new WeakMap()
-const fullAdapterContractCompat = new WeakMap()
+const adapterContractCompat = Array.from({ length: 4 }, () => new WeakMap())
 
 export const DEFAULT_ADAPTER_RECONCILE_MAX_PASSES = 32
 
@@ -37,13 +36,18 @@ function noImageRequestPricing() {
   return undefined
 }
 
+function normalizedImageRequestTarget(_provider, _model, image) {
+  return { width: image.width, height: image.height, maxBytes: image.bytes }
+}
+
 /**
  * Normalize Vision Router-owned duck-typed adapters to the Host adapter
  * contracts that have base-class defaults in newer DSH releases.
  *
  * DSH 0.1.1 started dispatching through adapter.prepareCall(). DSH 0.1.2 adds
  * adapter.imageRequestPricing() and the token meter resolves it synchronously
- * on every measurement. Vision Router intentionally registers plain adapter
+ * on every measurement. DSH 0.2.1 adds adapter.imageRequestTarget() for
+ * screenshot consumers, with a base-class identity projection default. Vision Router intentionally registers plain adapter
  * objects, so neither inherited default exists unless we materialize it here.
  *
  * Request-image pricing is deliberately NOT delegated to some other adapter.
@@ -51,6 +55,9 @@ function noImageRequestPricing() {
  * only that exact route can truthfully declare its projection. `undefined` is
  * LlmAdapter's default and keeps the Host's provider-neutral heuristic. An
  * adapter that explicitly implements imageRequestPricing remains authoritative.
+ * Image request targets likewise default to the Host's normalized-image
+ * identity projection, never a guessed provider-specific resize. An explicit
+ * route-owned imageRequestTarget remains authoritative.
  *
  * The compatibility method is installed non-enumerably on extensible adapters
  * to preserve registration identity. Frozen/sealed adapters fall back to one
@@ -61,17 +68,20 @@ export function ensureAdapterContracts(adapter, options = {}) {
   if (!isAdapter(adapter)) return adapter
 
   const includeImageRequestPricing = options.imageRequestPricing === true
+  const includeImageRequestTarget = options.imageRequestTarget === true
   const needsPrepareCall = !hasFunction(adapter, 'prepareCall')
   const needsImageRequestPricing =
     includeImageRequestPricing && !hasFunction(adapter, 'imageRequestPricing')
-  if (!needsPrepareCall && !needsImageRequestPricing) return adapter
+  const needsImageRequestTarget = includeImageRequestTarget && !hasFunction(adapter, 'imageRequestTarget')
+  if (!needsPrepareCall && !needsImageRequestPricing && !needsImageRequestTarget) return adapter
 
-  const cache = includeImageRequestPricing ? fullAdapterContractCompat : preparedAdapterCompat
+  const cache = adapterContractCompat[Number(includeImageRequestPricing) + 2 * Number(includeImageRequestTarget)]
   const cached = cache.get(adapter)
   if (cached) return cached
 
   const prepareCall = needsPrepareCall ? createPrepareCallFallback(adapter) : undefined
   const imageRequestPricing = needsImageRequestPricing ? noImageRequestPricing : undefined
+  const imageRequestTarget = needsImageRequestTarget ? normalizedImageRequestTarget : undefined
   const descriptors = {}
   if (prepareCall !== undefined) {
     descriptors.prepareCall = {
@@ -87,6 +97,13 @@ export function ensureAdapterContracts(adapter, options = {}) {
       value: imageRequestPricing,
     }
   }
+  if (imageRequestTarget !== undefined) {
+    descriptors.imageRequestTarget = {
+      configurable: true,
+      writable: true,
+      value: imageRequestTarget,
+    }
+  }
 
   // Preserve the exact adapter object whenever possible. Some runtime paths
   // retain registration.adapter and compare/reuse it later, so mutation is less
@@ -103,6 +120,9 @@ export function ensureAdapterContracts(adapter, options = {}) {
         if (property === 'imageRequestPricing' && imageRequestPricing !== undefined) {
           return imageRequestPricing
         }
+        if (property === 'imageRequestTarget' && imageRequestTarget !== undefined) {
+          return imageRequestTarget
+        }
         const value = Reflect.get(target, property, target)
         if (typeof value !== 'function') return value
         let bound = boundFunctions.get(value)
@@ -131,6 +151,14 @@ function llmSupportsImageRequestPricing(llm) {
   }
 }
 
+function llmSupportsImageRequestTarget(llm) {
+  try {
+    return typeof Reflect.get(llm, 'imageRequestTarget', llm) === 'function'
+  } catch {
+    return false
+  }
+}
+
 function wrapLlmService(llm) {
   if (!isAdapter(llm)) return llm
   const cached = wrappedLlmServices.get(llm)
@@ -140,6 +168,7 @@ function wrapLlmService(llm) {
   // historical adapter shape, while Hosts exposing the new route-pricing seam
   // receive the base-class-compatible default on our duck-typed adapters.
   const includeImageRequestPricing = llmSupportsImageRequestPricing(llm)
+  const includeImageRequestTarget = llmSupportsImageRequestTarget(llm)
   const wrapped = new Proxy(llm, {
     get(target, property) {
       if (property === 'registerAdapter') {
@@ -149,7 +178,10 @@ function wrapLlmService(llm) {
           registerAdapter.call(
             target,
             providers,
-            ensureAdapterContracts(adapter, { imageRequestPricing: includeImageRequestPricing }),
+            ensureAdapterContracts(adapter, {
+              imageRequestPricing: includeImageRequestPricing,
+              imageRequestTarget: includeImageRequestTarget,
+            }),
             ...rest,
           )
       }
@@ -238,8 +270,9 @@ export function createCoalescingRunner(run, options = {}) {
  * their native event semantics.
  *
  * The same deepest registration boundary also normalizes Vision Router-owned
- * adapter contracts: prepareCall for DSH 0.1.1+, and imageRequestPricing when
- * the Host exposes the DSH 0.1.2 route-pricing seam. This stays scoped to the
+ * adapter contracts: prepareCall for DSH 0.1.1+, imageRequestPricing when
+ * the Host exposes the DSH 0.1.2 route-pricing seam, and imageRequestTarget
+ * when the Host exposes the DSH 0.2.1 screenshot projection seam. This stays scoped to the
  * wrapped context instead of monkey-patching the Host LLM service process-wide.
  */
 export function contextWithCoalescedAdapterUpdates(ctx) {

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

@@ -996,11 +996,8 @@ export const CLIENT_PRESENTATION_PRELUDE = String.raw`(function(){
     return function(){ tag.remove(); };
   }
 
-  // A presented image that mounts below the reader is the same as not being shown: the card
-  // renders next to its tool call, and a reader who is at the end of a long conversation has
-  // that call thousands of pixels above them. The card calls this on mount; it only moves the
-  // reader for content that arrived below the viewport — a card that is already visible is left
-  // alone, and so is history above the reader when a session is opened.
+  // A fresh presented image below the reader is the same as not being shown. Centre only that
+  // card; visible cards and history on either side of a restored viewport stay untouched.
   function focusPresentedCard(node, viewportHeight) {
     if (!node || typeof node.getBoundingClientRect !== 'function') return false;
     var rect = node.getBoundingClientRect();
@@ -1022,12 +1019,25 @@ export const CLIENT_PRESENTATION_PRELUDE = String.raw`(function(){
     return false;
   }
 
+  // New Hosts expose phase; supported DSH 0.1.5 instead marks settled blocks as
+  // 'tool-result'. Normalize the [phase, block kind] tuple without raising the Host floor.
+  function isPresentedResultState(state) {
+    var phase = state && state[0];
+    return phase !== undefined ? phase === 'result' : !!state && state[1] === 'tool-result';
+  }
+
+  // Restored history starts settled on both sides of the comparison. Only a live transition into
+  // an image-bearing result is fresh presentation.
+  function shouldFocusPresentedCard(previousState, state, imageCount) {
+    return imageCount > 0 &&
+      isPresentedResultState(state) &&
+      !isPresentedResultState(previousState);
+  }
+
   try {
-    globalThis.__dvrPresentFocus = function () {
-      if (typeof document === 'undefined') return false;
-      var cards = document.querySelectorAll('[data-dvr-present]');
-      var last = cards[cards.length - 1];
-      return last ? focusPresentedCard(last, globalThis.innerHeight || 0) : false;
+    globalThis.__dvrPresentFocus = function (node, previousState, state, imageCount) {
+      return shouldFocusPresentedCard(previousState, state, imageCount) &&
+        focusPresentedCard(node, globalThis.innerHeight || 0);
     };
   } catch (_) {}
 
@@ -1160,6 +1170,13 @@ export const CLIENT_PRESENTATION_PRELUDE = String.raw`(function(){
         var complete = usable && livePair.mode !== 'unavailable';
         var settledMode = React.useRef(null);
         var toggleTransition = React.useRef(null);
+        // The Host may render a ready directory while the RPC that selected
+        // it is still in flight. Keep only an in-flight transaction fence here,
+        // never a second source of truth for Vision ON/OFF.
+        var selectionTransaction = React.useRef(null);
+        var refreshSelection = React.useState(0)[1];
+        var selectionInFlight = !!(selectionTransaction.current &&
+          selectionTransaction.current.directory === directory);
         if (settledMode.current && settledMode.current.directory !== directory) settledMode.current = null;
         if (toggleTransition.current && toggleTransition.current.directory !== directory) toggleTransition.current = null;
         if (complete) settledMode.current = { directory: directory, mode: livePair.mode };
@@ -1184,7 +1201,7 @@ export const CLIENT_PRESENTATION_PRELUDE = String.raw`(function(){
         var toastState = React.useState(null);
         var toast = toastState[0];
         var setToast = toastState[1];
-        var busy = state.status === 'selecting';
+        var busy = state.status === 'selecting' || selectionInFlight;
         var loading = settling;
         var removed = props.session && props.session.removed === true;
         var disabled = props.available !== true || removed || busy || loading || livePair.mode === 'unavailable';
@@ -1226,15 +1243,23 @@ export const CLIENT_PRESENTATION_PRELUDE = String.raw`(function(){
           'data-active': active ? 'true' : 'false',
           'data-dimmed': disabled && !ownSettling && (livePair.mode === 'unavailable' || loading) ? 'true' : 'false',
           onClick: function() {
-            if (disabled || !pair.target || typeof props.select !== 'function') return;
+            if (disabled || !pair.target || typeof props.select !== 'function' ||
+              (selectionTransaction.current && selectionTransaction.current.directory === directory)) return;
             var target = pair.target;
+            var ticket = { directory: directory, target: target };
+            selectionTransaction.current = ticket;
+            refreshSelection(function(revision){ return revision + 1; });
             toggleTransition.current = {
               directory: directory,
               target: target,
               seenSelecting: false
             };
             setToast(null);
-            void props.select(target).then(function(accepted){
+            var pending;
+            try { pending = props.select(target); }
+            catch (error) { pending = Promise.reject(error); }
+            void Promise.resolve(pending).then(function(accepted){
+              if (selectionTransaction.current !== ticket) return;
               if (!accepted) {
                 toggleTransition.current = null;
                 announceRejectedSelection();
@@ -1245,6 +1270,14 @@ export const CLIENT_PRESENTATION_PRELUDE = String.raw`(function(){
               if (!latest || (latest.status !== 'selecting' && latest.status !== 'idle' && latest.status !== 'loading')) {
                 toggleTransition.current = null;
               }
+            }, function(error){
+              if (selectionTransaction.current !== ticket) return;
+              toggleTransition.current = null;
+              announceRejectedSelection();
+            }).finally(function(){
+              if (selectionTransaction.current !== ticket) return;
+              selectionTransaction.current = null;
+              refreshSelection(function(revision){ return revision + 1; });
             });
           }
         },

package/lib/client.js

@@ -268,18 +268,18 @@ openLogFolder,
       catalogFallback: '），模型字段已退回手动输入。',
       catalogPartialFailure: '部分已配置供应商的模型目录加载失败：{detail}。这些供应商可能仍会显示在「设置 → 模型」中，但暂时不会出现在这里。',
       visionCapsLoading: '正在读取模型图片能力声明（仅用于提示，不影响可选模型）…',
-      visionCapsError: '视觉能力元数据暂时不可用；模型仍可选择，实际可用性将由供应商已注册的 DSH adapter 在调用时验证。',
-      visionCapsFiltered: '模型能力声明只用于提示，不再作为准入条件；未声明图片能力或标成仅文本的生成式模型也可选择，调用失败会自动回退。',
-      visionCapabilityUndeclaredWarning: '此模型暂未附图片能力声明，不影响使用：调用时会实际尝试，失败后自动切换下一个模型。',
-      visionCapabilityTextOnlyWarning: '此模型被标记为仅文本，仍可直接使用：调用时自动验证图片能力，不支持会自动切换下一个模型。',
-      visionCapabilityUnknownWarning: '此模型的图片能力会在调用时自动验证，无需额外配置；失败会自动切换下一个模型。',
+      visionCapsError: '能力数据不可用，仍可选择模型；实际图片投递取决于Host声明及传输支持。',
+      visionCapsFiltered: '能力声明不限制后端选择；Host标为仅文本可能导致图片无法送达。',
+      visionCapabilityUndeclaredWarning: '图片能力未知：调用时尝试原生adapter，失败后尝试下一后端。',
+      visionCapabilityTextOnlyWarning: 'Host 将此模型标为仅文本，adapter 调用前会剥离图片；仅兼容的 HTTP Chat Completions 可桥接。若支持图片，在 DSH「设置 → 模型 → 输入类型」勾选图片；旧 Host 设 llm-pi-ai 的 input: [text, image] 或 llm-deepseek 的 inputModalities: [text, image] 后重载配置，否则跳过此后端。',
+      visionCapabilityUnknownWarning: '图片能力待验证；调用失败会尝试下一后端。',
       visionCapsEmptyTitle: '没有可选的用户视觉模型',
       visionCapsEmptyBody: '检测到 {count} 个用户模型，但它们都没有被 DSH 明确标记为支持图片，因此已被安全隐藏。',
       visionCapsHiddenPrefix: '被隐藏的模型：',
       visionCapsReasonMissingImage: '未声明 image',
       visionCapsReasonUnverified: '无法验证图片能力',
       visionCapsHiddenMore: '另有 {count} 个模型未显示',
-      visionCapsMissingImageHint: '如果这里有你刚在「设置 → 模型 → 添加自定义提供方」中添加的视觉模型：可以在高级设置「额外视觉模型」的下拉里选中它直接启用；或按 DSH 的方式在 $DSH_HOME/settings.yaml 为该模型补上 input: [text, image]（或为整个提供方补 defaultInput: [text, image]）。DSH 当前 Web 表单不会写入这个字段。',
+      visionCapsMissingImageHint: '若模型确实支持图片，请到 DSH「设置 → 模型 → 输入类型」启用图片并保存；旧 Host 可在 profile 的 cordis.patch.yml 中声明正确的模型输入类型。仅添加额外视觉模型标记不能改变 Host 图片投递。',
       visionCapsRetry: '重新检测模型',
       chainInvalidCurrent: '当前保存的后端已不在可调用模型目录中，或属于非生成式/递归路由，运行时会跳过：',
       retryCatalog: '重试加载目录',
@@ -301,7 +301,7 @@ openLogFolder,
       extraVisionModelsHint:
         '这个设置不再用于“解锁”下拉或允许调用；所有可调用生成式模型本来就能被选择。' +
         '只有当你希望把某个未声明图片能力的模型明确标记为视觉模型时才需要填写。' +
-        '实际调用仍优先走 DSH adapter；只有明确的 http(s) OpenAI Chat Completions 渠道才可能使用直连兼容兜底。',
+        '此标记不会更改 Host 输入声明。仅经验证的 HTTP Chat Completions 渠道可直接桥接；其他纯文本声明会被安全拒绝。',
       groupRoutes: '路由名称',
       groupProxy: '网络',
       networkAuthorityHint: '默认不接管网络出口：Vision Router 沿用 DSH/Host 当前网络路径。下方代理只用于需要给视觉请求单独指定出口的高级覆盖。',
@@ -554,18 +554,18 @@ openLogFolder,
       catalogFallback: '); model fields fell back to free-text input.',
       catalogPartialFailure: 'Some configured providers failed to load their model catalog: {detail}. They may still appear in Settings → Models, but are temporarily unavailable here.',
       visionCapsLoading: 'Reading model image-capability metadata (advisory only; it does not hide selectable models)…',
-      visionCapsError: 'Vision capability metadata is temporarily unavailable; models remain selectable and the registered DSH adapter will verify actual support when called.',
-      visionCapsFiltered: 'Capability metadata is advisory, not an admission gate. Generative models with undeclared or text-only metadata remain selectable and failures automatically fall through.',
-      visionCapabilityUndeclaredWarning: 'This model has no image-capability declaration, but it stays usable: Vision Router tries it on the call and falls through automatically on failure.',
-      visionCapabilityTextOnlyWarning: 'This model is marked text-only, but you can still use it: image support is verified on the call and failures fall through automatically.',
-      visionCapabilityUnknownWarning: 'Image capability is verified automatically on the call — no extra setup needed; failures fall through to the next model.',
+      visionCapsError: 'Capabilities unavailable; models remain selectable, but image delivery depends on Host input declaration.',
+      visionCapsFiltered: 'Model capability labels do not restrict selection; a Host text-only label may block image delivery.',
+      visionCapabilityUndeclaredWarning: 'Image capability unknown; Vision Router tries the adapter and falls through on failure.',
+      visionCapabilityTextOnlyWarning: 'Host text-only strips images before adapter; only verified HTTP Chat Completions can bridge. If supported, enable Image in DSH Settings → Models → Input types. Older Hosts: llm-pi-ai input: [text, image]; llm-deepseek inputModalities: [text, image]. Otherwise skip this backend.',
+      visionCapabilityUnknownWarning: 'Image capability is checked at call time; failures fall through.',
       visionCapsEmptyTitle: 'No selectable user vision models',
       visionCapsEmptyBody: 'DSH reported {count} user models, but none are explicitly marked as accepting images, so Vision Router hid them safely.',
       visionCapsHiddenPrefix: 'Hidden models:',
       visionCapsReasonMissingImage: 'image input not declared',
       visionCapsReasonUnverified: 'image capability could not be verified',
       visionCapsHiddenMore: '{count} more models not shown',
-      visionCapsMissingImageHint: 'If one of these is a vision model you just added through Settings → Models → Add custom provider: select it in the “Extra vision models” dropdown under Advanced to enable it directly; or follow the DSH way and add input: [text, image] to that model in $DSH_HOME/settings.yaml (or defaultInput: [text, image] to the provider). The current DSH Web form does not write this field.',
+      visionCapsMissingImageHint: 'For a model that truly accepts images, enable Image in DSH Settings → Models → Input types. Older Hosts: set the correct input field in your profile cordis.patch.yml. Extra vision labels cannot change Host pixel delivery.',
       visionCapsRetry: 'Re-detect models',
       chainInvalidCurrent: 'This saved backend is no longer callable, or is a non-generative/recursive route, so runtime will skip it: ',
       retryCatalog: 'Retry catalog',
@@ -587,7 +587,7 @@ openLogFolder,
       extraVisionModelsHint:
         'This setting no longer unlocks the picker or admission: every callable generative model is selectable already. ' +
         'Use it only when you want to explicitly label an undeclared model as visual. ' +
-        'Runtime still tries the DSH adapter first; only a confirmed http(s) OpenAI Chat Completions channel may use the direct compatibility bridge.',
+        'This label does not change Host input declarations. Verified HTTP Chat Completions can bridge; other explicit text-only routes fail safely.',
       groupRoutes: 'Route names',
       groupProxy: 'Network',
       networkAuthorityHint: 'Vision Router does not own egress by default: it follows the current DSH/Host network path. The proxy below is only an advanced vision-request override.',
@@ -845,11 +845,12 @@ openLogFolder,
     function visionCapabilityWarningKey(capability, status) {
       if (status === 'loading' || status === 'idle') return undefined
       if (status === 'error' || !capability) return 'visionCapabilityUnknownWarning'
-      if (capability.attemptable === false || capability.image === true) return undefined
-      const modalities = Array.isArray(capability.inputModalities) ? capability.inputModalities : []
-      return modalities.length > 0 && !modalities.includes('image')
-        ? 'visionCapabilityTextOnlyWarning'
-        : 'visionCapabilityUndeclaredWarning'
+      if (capability.attemptable === false) return undefined
+      const declared = Array.isArray(capability.hostInputModalities)
+        ? capability.hostInputModalities : capability.inputModalities
+      const modalities = Array.isArray(declared) ? declared : []
+      if (modalities.length > 0 && !modalities.includes('image')) return 'visionCapabilityTextOnlyWarning'
+      return capability.image === true ? undefined : 'visionCapabilityUndeclaredWarning'
     }
 
     // ── field specs ──────────────────────────────────────────────────────────
@@ -4756,12 +4757,11 @@ openLogFolder,
           }
         }, ownerToken)
       }
-      // Follow the app language: register our dictionaries and re-read them
-      // whenever the user switches the locale in Settings → General.
+      // Keep card copy in sync with the app locale.
       ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'vision-router: card locale')
       const t = ctx.locale.bind(NS)
       const VisionPresentCard = (props) => {
-        const { block, sessionId } = props
+        const { block, sessionId, phase } = props
         const content = block && Array.isArray(block.content) ? block.content : []
         const images = content
           .filter((item) => item && item.type === 'image' && item.attachment)
@@ -4770,7 +4770,13 @@ openLogFolder,
         const imageKeySignature = JSON.stringify(imageKeys)
         const imageOwnerToken = React.useRef({}).current
         const ownedImageKeys = React.useRef(new Set())
-        React.useEffect(() => { if (globalThis.__dvrPresentFocus) globalThis.__dvrPresentFocus() }, [imageKeySignature])
+        const presentNode = React.useRef()
+        const focusState = React.useRef([phase, block?.kind])
+        React.useEffect(() => {
+          const next = [phase, block?.kind]
+          globalThis.__dvrPresentFocus?.(presentNode.current, focusState.current, next, images.length)
+          focusState.current = next
+        }, [phase, block?.kind, imageKeySignature])
         React.useEffect(() => {
           const current = new Set(imageKeys)
           for (const key of ownedImageKeys.current) {
@@ -4810,7 +4816,7 @@ openLogFolder,
         }
         return React.createElement(
           'div',
-          { 'data-dvr-present': 'true', style: { display: 'flex', flexDirection: 'column', alignItems: 'flex-start', gap: 6, padding: '4px 0' } },
+          { ref: presentNode, 'data-dvr-present': 'true', style: { display: 'flex', flexDirection: 'column', alignItems: 'flex-start', gap: 6, padding: '4px 0' } },
           parsed && typeof parsed.label === 'string' && parsed.label !== 'image'
             ? React.createElement(
                 'div',

package/lib/core-primitives.js

@@ -2768,6 +2768,8 @@ export function decideVisionBackendCapability(info, provider, model, extraVision
       image: true,
       attemptable: true,
       inputModalities: [...new Set([...inputModalities, 'image'])],
+      ...(inputModalities.length > 0 && !inputModalities.includes('image')
+        ? { hostInputModalities: [...inputModalities] } : {}),
       inferred: 'override',
       reason: undefined,
     }
@@ -2789,6 +2791,8 @@ export function decideVisionBackendCapability(info, provider, model, extraVision
       image: true,
       attemptable: true,
       inputModalities: [...new Set([...inputModalities, 'image'])],
+      ...(inputModalities.length > 0 && !inputModalities.includes('image')
+        ? { hostInputModalities: [...inputModalities] } : {}),
       inferred: 'name',
       reason: undefined,
     }

package/lib/diagnostic-redaction.js

@@ -20,9 +20,15 @@ const CREDENTIAL_SHAPE_PATTERNS = [
   // (the log sink has always consumed it) while `,` separates what follows.
   [/\b(Authorization\s*[:=]\s*)(?:[A-Za-z][A-Za-z0-9._-]*\s+)?[^\s,]+/gi, `$1${REDACTED}`],
   [/\b(Proxy-Authorization\s*[:=]\s*)(?:[A-Za-z][A-Za-z0-9._-]*\s+)?[^\s,]+/gi, `$1${REDACTED}`],
-  // Cookies are `name=value; name=value` on one line and there is no safe way to
-  // guess which pair carries the session, so the whole header value goes.
-  [/\b((?:Set-)?Cookie\s*[:=]\s*)[^\r\n]+/gi, `$1${REDACTED}`],
+  // A real Cookie/Set-Cookie header owns the remainder of its line, so redact the
+  // whole value there. The same words also appear inside arbitrary diagnostics,
+  // URL query fragments and object dumps; those contexts must keep unrelated text.
+  [/^([ \t]*(?:Set-)?Cookie\s*:\s*)[^\r\n]+/gim, `$1${REDACTED}`],
+  // Inline colon form: redact one scalar or a semicolon-separated cookie-pair run,
+  // then stop at an unrelated comma/word so support diagnostics remain readable.
+  [/\b((?:Set-)?Cookie\s*:\s*)(?:"[^"\r\n]*"|'[^'\r\n]*'|[^;\s,&"']+(?:\s*;\s*[^=;\s,&"']+\s*=\s*(?:"[^"\r\n]*"|'[^'\r\n]*'|[^;\s,&"']+))*)/gi, `$1${REDACTED}`],
+  // Assignment/query form: bound the value at ordinary diagnostic separators.
+  [/\b((?:Set-)?Cookie\s*=\s*)(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s,&"']+)/gi, `$1${REDACTED}`],
   // URL userinfo (`scheme://user:secret@host`) without needing a URL parser, so
   // the log path — which never parsed URLs — covers it too.
   [/\b([a-z][a-z0-9+.-]*:\/\/)[^/\s@]+@/gi, `$1${REDACTED}@`],

package/lib/maintenance-routes.js

@@ -1,5 +1,6 @@
 import { randomBytes } from 'node:crypto'
 import { createCachedUpdateChecker } from './update-check.js'
+import { isLocalUiRequest } from './web-capability-boundary.js'
 import { detectDshSelfUpdatePlan, runDshPluginUpdate } from './self-update.js'
 
 function json(res, status, body, headers = {}) {
@@ -66,7 +67,12 @@ export function installVisionMaintenanceRoutes(ctx, options = {}) {
             res.end()
             return
           }
-          const force = /(?:[?&])force=1(?:&|$)/.test(String(req.url ?? ''))
+          // Forced refresh causes outbound Host network traffic. Remote Web may
+          // read already-cached update status, but must never bypass the cache
+          // with ?force=1. Reuse the existing local-UI provenance boundary;
+          // do not trust the query string or caller-supplied proxy headers.
+          const requestedForce = /(?:[?&])force=1(?:&|$)/.test(String(req.url ?? ''))
+          const force = requestedForce && isLocalUiRequest(req)
           const result = await updateChecker.check(force)
           json(res, 200, updateResultForClient(result), { 'cache-control': 'no-store' })
         },

package/lib/proxy-routing.js

@@ -9,6 +9,21 @@ export function visionProxyOverrideConfigured(config = {}) {
         : undefined;
     return typeof value === 'string' && value.trim() !== '';
 }
+function canonicalIpv6Literal(value) {
+    if (!value.includes(':'))
+        return undefined;
+    try {
+        const serialized = new URL(`http://[${value}]/`).hostname;
+        if (!serialized.startsWith('[') || !serialized.endsWith(']'))
+            return undefined;
+        return serialized.slice(1, -1).toLowerCase();
+    }
+    catch {
+        // Invalid or URL-unrepresentable literals (for example zone-id spellings)
+        // keep the existing conservative string semantics instead of broadening admission.
+        return undefined;
+    }
+}
 /**
  * Canonicalize a configured/request hostname for proxy admission only.
  * Persisted settings stay untouched; this removes DNS presentation differences
@@ -22,26 +37,30 @@ export function canonicalProxyHost(value) {
         host = host.slice(0, -1);
     if (host === '')
         return '';
-    // A `*.host` entry means "this host and its subdomains", which is exactly what the matcher
-    // already does for a bare hostname. `domainToASCII` rejects the star, so leaving it in place
-    // makes the entry equal no real hostname: the configured host silently proxies nothing.
+    // `*.host` and cookie-domain `.host` entries both mean "this host and its subdomains",
+    // which is exactly what the matcher already does for a bare hostname. Leaving either prefix
+    // in place makes the entry equal no real hostname: the configured host silently proxies nothing.
     if (host.startsWith('*.'))
         host = host.slice(2);
+    else if (host.startsWith('.'))
+        host = host.slice(1);
     if (host === '')
         return '';
-    // WHATWG URL.hostname keeps IPv6 literals bracketed. domainToASCII does not
-    // accept an IPv6 literal at all, so case-fold it directly. The brackets are
-    // pure spelling for the same address: stripping them is what lets a configured
-    // `::1` match a URL-derived `[::1]`. A bracketed non-literal (say
-    // `[example.com]`) keeps its spelling, so nothing about DNS is widened.
+    // WHATWG URL.hostname serializes IPv6 literals to one compressed spelling.
+    // Re-serialize configured literals through the same parser before comparing so
+    // equivalent legal spellings (expanded/compressed, case, leading zeroes and
+    // IPv4-mapped forms) cannot silently bypass a proxy override. A bracketed
+    // non-literal keeps its spelling, and invalid/URL-unrepresentable colon forms
+    // retain the previous lowercase-only fallback rather than widening admission.
     if (host.startsWith('[') && host.endsWith(']')) {
         const literal = host.slice(1, -1).trim();
         if (literal === '')
             return '';
-        return literal.includes(':') ? literal.toLowerCase() : host.toLowerCase();
+        return canonicalIpv6Literal(literal)
+            ?? (literal.includes(':') ? literal.toLowerCase() : host.toLowerCase());
     }
     if (host.includes(':'))
-        return host.toLowerCase();
+        return canonicalIpv6Literal(host) ?? host.toLowerCase();
     const ascii = domainToASCII(host);
     return (ascii || host).toLowerCase();
 }

package/lib/vision-backend-runtime-policy.js

@@ -174,7 +174,7 @@ async function toOpenAIMessages(ctx, messages) {
   return out
 }
 
-async function resolvedHostInfo(llm, call) {
+export async function resolvedHostInfo(llm, call) {
   if (typeof llm?.prepareCall === 'function') {
     try {
       const prepared = await llm.prepareCall(
@@ -195,7 +195,7 @@ async function resolvedHostInfo(llm, call) {
   return undefined
 }
 
-function localOnlyVisionCallAllowed(core, config, provider, model) {
+export function localOnlyVisionCallAllowed(core, config, provider, model) {
   if (config?.localOnlyVision !== true) return true
   if (provider !== 'vision-http') return false
   const allowed = []
@@ -346,7 +346,7 @@ function llmWithRuntimePolicy(ctx, llm, options) {
                   plan.reason,
                 )
                 yield* failureStream(
-                  `vision backend ${provider}/${model} is declared text-only by the Host and no safe pixel transport is available`,
+                  `vision backend ${provider}/${model} is declared text-only by the Host, which strips image pixels before the registered adapter runs; no safe HTTP image bridge is available. If this endpoint really supports images, enable Image under DSH Settings > Models > provider > Customized settings > Model options > Input types (when available); on older Hosts set the provider-specific model field (llm-pi-ai: input: [text, image]; llm-deepseek: inputModalities: [text, image]), then reload model configuration. Otherwise choose a declared image-capable backend. Direct bridging is supported only for verified HTTP OpenAI Chat Completions endpoints.`,
                 )
                 return
               }