dsh-vision-router 3.0.3 → 3.0.4

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

@@ -1170,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 };
@@ -1194,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';
@@ -1236,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();
@@ -1255,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 ──────────────────────────────────────────────────────────

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/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/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
               }

package/lib/vision-background-benchmark.js

@@ -10,6 +10,7 @@ import { resolveVisionRoutingAuthority } from './vision-routing-authority.js'
 import { redactDiagnosticText } from './diagnostic-redaction.js'
 import { installVisionExactCheckClient } from './vision-exact-check-client.js'
 import { createImageInputVerdictStore } from './vision-image-input-verdict.js'
+import { hostImageDeliveryFromInfo, localOnlyVisionCallAllowed, resolvedHostInfo } from './vision-backend-runtime-policy.js'
 import { createBackgroundBenchmarkStopStore } from './vision-background-stop-store.js'
 import { backgroundFailurePolicy } from './vision-background-failure-policy.js'
 import { isLocalUiRequest } from './web-capability-boundary.js'
@@ -288,9 +289,18 @@ function candidateBlockedByFailure(backoff, candidate, at) {
   return false
 }
 
-async function imageVerdictFor(imageVerdictStore, candidate) {
+async function currentHostImageDelivery(ctx, provider, model) {
+  if (provider === 'vision-http') return 'native-image'
+  return hostImageDeliveryFromInfo(await resolvedHostInfo(ctx?.llm, { provider, model }))
+}
+
+async function imageVerdictFor(imageVerdictStore, candidate, ctx) {
   if (!candidate?.endpointFingerprint || typeof imageVerdictStore?.get !== 'function') return undefined
-  try { return await imageVerdictStore.get(candidate.endpointFingerprint) } catch { return undefined }
+  try {
+    const verdict = await imageVerdictStore.get(candidate.endpointFingerprint)
+    if (!verdict || verdict.hostMode !== 'native-image') return undefined
+    return await currentHostImageDelivery(ctx, candidate.provider, candidate.model) === 'native-image' ? verdict : undefined
+  } catch { return undefined }
 }
 
 async function chooseNextWork({ ctx, config, core, store, now, backoff, excluded, imageVerdictStore, backgroundStopStore }) {
@@ -302,7 +312,7 @@ async function chooseNextWork({ ctx, config, core, store, now, backoff, excluded
   await restorePersistentStops(backoff, collected, backgroundStopStore, ctx, now)
   const candidates = []
   for (const candidate of collected) {
-    const verdict = await imageVerdictFor(imageVerdictStore, candidate)
+    const verdict = await imageVerdictFor(imageVerdictStore, candidate, ctx)
     if (verdict?.state === 'unsupported') {
       excluded.set(candidate.key, { key: candidate.key, reason: 'measured-text-only' })
       continue
@@ -470,6 +480,13 @@ export async function runExactVisionCheck({ ctx, config, core, store, provider,
   const wantedModel = typeof model === 'string' ? model.trim() : ''
   if (!wantedProvider || !wantedModel) throw Object.assign(new Error('provider and model are required'), { code: 'VISION_CHECK_BACKEND_REQUIRED' })
   const current = activeSettings(ctx, config)
+  if (!localOnlyVisionCallAllowed(core, current, wantedProvider, wantedModel)) {
+    const error = new Error('local-only vision policy prevents testing a nonlocal backend')
+    error.code = 'VISION_LOCAL_ONLY_POLICY'
+    error.benchmarkClass = 'host-configuration'
+    throw error
+  }
+  const declaredBefore = await currentHostImageDelivery(ctx, wantedProvider, wantedModel)
   const candidates = await collectVisionRoutingCandidates(ctx, current, core, store)
   const candidate = candidates.find((entry) => entry?.provider === wantedProvider && entry?.model === wantedModel)
     ?? exactAdapterCandidate(ctx, core, wantedProvider, wantedModel)
@@ -513,6 +530,12 @@ export async function runExactVisionCheck({ ctx, config, core, store, provider,
     remaining(),
     'exact image check timed out',
   )
+  if (declaredBefore !== await currentHostImageDelivery(ctx, wantedProvider, wantedModel)) {
+    const error = new Error('Host image-input declaration changed during the test; retest the model')
+    error.code = 'VISION_CHECK_STALE_CONFIG'
+    error.benchmarkClass = 'host-configuration'
+    throw error
+  }
   return {
     ok: true,
     key: candidate.key,
@@ -602,13 +625,15 @@ export function createBackgroundCapabilityProfiler({
     excluded.set(candidate.key, { key: candidate.key, reason: 'measured-text-only' })
     clearDeferredForCandidate(candidate)
     await clearPersistentStopsForCandidate(candidate)
-    if (candidate.endpointFingerprint && typeof imageVerdictStore?.markUnsupported === 'function') {
+    if (candidate.endpointFingerprint && typeof imageVerdictStore?.markUnsupported === 'function'
+      && await currentHostImageDelivery(ctx, candidate.provider, candidate.model) === 'native-image') {
       try {
         await imageVerdictStore.markUnsupported({
           fingerprint: candidate.endpointFingerprint,
           key: candidate.key,
           provider: candidate.provider,
           model: candidate.model,
+          hostMode: 'native-image',
           measuredAt: Number(now()),
         })
       } catch (error) {
@@ -1140,7 +1165,9 @@ export function installBackgroundCapabilityProfiling(ctx, config, core, store, o
             const timedOut = error?.name === 'TimeoutError' || error?.name === 'AbortError' || /timed out|timeout|deadline/i.test(String(error?.message ?? ''))
             const failureClass = error?.benchmarkClass ?? classifyCapabilityBenchmarkFailure(error)
             const unsupportedImage = !timedOut && failureClass === 'unsupported-image'
-            if (unsupportedImage) await profiler.recordImageUnsupported(body.provider, body.model)
+            if (unsupportedImage && await currentHostImageDelivery(ctx, body.provider, body.model) === 'native-image') {
+              await profiler.recordImageUnsupported(body.provider, body.model)
+            }
             const code = timedOut
               ? 'VISION_CHECK_TIMEOUT'
               : unsupportedImage
@@ -1151,6 +1178,7 @@ export function installBackgroundCapabilityProfiling(ctx, config, core, store, o
               'VISION_CHECK_INVALID_JSON',
               'VISION_CHECK_BACKEND_REQUIRED',
               'VISION_CHECK_BACKEND_STALE',
+              'VISION_CHECK_STALE_CONFIG',
             ]).has(code)
             sendJson(res, unsupportedImage ? 422 : clientError ? 400 : 502, {
               ok: false,

package/lib/vision-capability-benchmark-service.js

@@ -14,6 +14,8 @@ import { resolveVisionCredential } from './vision-capability-identity.js'
 import { redactDiagnosticText } from './diagnostic-redaction.js'
 import { wireSessionAffinityId } from './session-affinity.js'
 import { streamWithVisionSessionAffinity } from './session-affinity-runtime.js'
+import { hostImageDeliveryFromInfo, resolvedHostInfo } from './vision-backend-runtime-policy.js'
+import { isLocalImageCapabilityAdmissionFailure } from './vision-execution-policy.js'
 import { streamWithLegacyGlobalProxyScope } from './legacy-global-proxy-boundary.js'
 import {
   hardenCapabilityBenchmarkFixture,
@@ -205,13 +207,28 @@ function failureError(failure, fallback) {
 async function collectStreamText(streamLike) {
   const stream = await streamLike
   let text = ''
-  for await (const chunk of stream) {
-    if (chunk && typeof chunk.text === 'string') text += chunk.text
-    if (chunk?.type === 'finish') {
-      const kind = chunk.reason?.kind
-      if (kind === 'error' || kind === 'aborted') throw failureError(chunk.reason?.failure, kind)
+  let observedOutput = false
+  try {
+    for await (const chunk of stream) {
+      // Any non-terminal output proves that the adapter began responding.
+      // Retrying through a second transport could duplicate a billed call.
+      if (chunk && chunk.type !== 'finish' && chunk.type !== 'error' && chunk.type !== 'aborted') {
+        observedOutput = true
+      }
+      if (chunk && typeof chunk.text === 'string') text += chunk.text
+      if (chunk?.type === 'finish') {
+        const kind = chunk.reason?.kind
+        if (kind === 'error' || kind === 'aborted') throw failureError(chunk.reason?.failure, kind)
+      }
+      if (chunk?.type === 'error' || chunk?.type === 'aborted') throw failureError(chunk.failure, chunk.type)
+    }
+  } catch (error) {
+    if (observedOutput) {
+      const failure = failureError(error)
+      failure.visionAdapterProducedOutput = true
+      throw failure
     }
-    if (chunk?.type === 'error' || chunk?.type === 'aborted') throw failureError(chunk.failure, chunk.type)
+    throw error
   }
   return text
 }
@@ -223,20 +240,22 @@ function tagInvocationError(value) {
   return error
 }
 
-function mayUseExactAdapterBridge(core, error, directProvider) {
-  if (directProvider === undefined) return false
-  try {
-    const classification = core?.classifyVisionFailure?.(error)
-    const kinds = core?.VISION_FAILURE_KINDS
-    const allowed = new Set([
-      kinds?.INVALID_REQUEST,
-      kinds?.NETWORK,
-      kinds?.OTHER,
-    ].filter(Boolean))
-    return classification && allowed.has(classification.kind)
-  } catch {
-    return false
-  }
+function mayUseExactAdapterBridge(_core, error, directProvider) {
+  if (directProvider === undefined || error?.visionAdapterProducedOutput === true) return false
+  // Share the runtime's exact pre-wire pi-ai admission predicate. Provider
+  // HTTP 400s, ambiguous image errors and network failures must never replay.
+  return isLocalImageCapabilityAdmissionFailure(error)
+}
+
+export function exactHostImageDeliveryPlan(info, candidate, core) {
+  const delivery = hostImageDeliveryFromInfo(info)
+  if (delivery !== 'text-projected') return { delivery, path: 'adapter' }
+  const verified = candidate?.evidenceScope === 'endpoint'
+    && candidate?.endpointConfig?.api === 'openai-completions'
+    && typeof candidate?.endpoint === 'string'
+    && typeof core?.isOpenAIHttpBridgeTransport === 'function'
+    && core.isOpenAIHttpBridgeTransport({ api: 'openai-completions', baseURL: candidate.endpoint })
+  return { delivery, path: verified ? 'http-direct' : 'refuse' }
 }
 
 function benchmarkMaxTokensForProvider(provider) {
@@ -295,6 +314,22 @@ export function createExactCapabilityInvoker(ctx, core, candidate, config, optio
       )
       const callSignal = mergedSignal(signal, AbortSignal.timeout(fixtureTimeoutMs))
       const exactHttpProvider = directProviderFor(candidate, config, core)
+      const hostInfo = candidate.provider === 'vision-http' ? undefined :
+        await resolvedHostInfo(ctx?.llm, { provider: candidate.provider, model: candidate.model, signal: callSignal })
+      const imagePlan = candidate.provider === 'vision-http'
+        ? { path: 'http-direct' }
+        : exactHostImageDeliveryPlan(hostInfo, candidate, core)
+      if (imagePlan.path === 'refuse') {
+        const error = new Error('Host declares this model text-only and removes image pixels before adapter dispatch; enable Image in DSH model input types, then retest')
+        error.code = 'VISION_IMAGE_DELIVERY_UNAVAILABLE'
+        error.benchmarkClass = 'host-configuration'
+        throw error
+      }
+      if (imagePlan.path === 'http-direct' && exactHttpProvider === undefined) {
+        const error = new Error('verified HTTP image bridge unavailable for this model')
+        error.code = 'CAPABILITY_BENCHMARK_PROTOCOL'
+        throw error
+      }
       const callExactHttp = async () => {
         if (exactHttpProvider === undefined) {
           const error = new Error('exact HTTP bridge is unavailable for this benchmark backend')
@@ -323,7 +358,7 @@ export function createExactCapabilityInvoker(ctx, core, candidate, config, optio
       let output
       let transport
       let latencyMs
-      if (candidate.provider === 'vision-http') {
+      if (candidate.provider === 'vision-http' || imagePlan.path === 'http-direct') {
         const direct = await callExactHttp()
         output = direct.output
         latencyMs = direct.latencyMs
@@ -404,8 +439,11 @@ async function declaredImageState(ctx, core, config, candidate) {
       candidate.model,
       config?.extraVisionModels,
     )
-    if (decision?.image === true) return 'declared'
-    if (decision?.image === false) return 'text-only'
+    const hostMode = hostImageDeliveryFromInfo(info)
+    if (hostMode === 'native-image') return 'declared'
+    if (hostMode === 'text-projected') return 'text-only'
+    // Name-based guesses and user labels do not rewrite Host input metadata.
+    if (decision?.image === true) return 'unknown'
   } catch {
     // Metadata is advisory. Exact configured routes remain force-testable.
   }