dsh-vision-router 2.3.0 → 3.0.1

package/index.js

@@ -1049,8 +1049,7 @@ export function apply(ctx, config = {}, runtime = {}) {
         yield { type: 'finish', reason: { kind: 'stop' } }
       },
     }
-    const httpHandle = ctx.llm.registerAdapter([HTTP_ROUTE], httpAdapter)
-    ctx.effect(() => httpHandle, 'vision-router: vision-http route')
+    ctx.llm.registerAdapter([HTTP_ROUTE], httpAdapter)
 
   }
 
@@ -1354,7 +1353,7 @@ export function apply(ctx, config = {}, runtime = {}) {
       const spec = wanted.get(provider)
       if (spec === undefined) {
         try {
-          held.handle()
+          held.registration()
           twinHandles.delete(provider)
         } catch (error) {
           ctx.logger?.warn(
@@ -1372,7 +1371,7 @@ export function apply(ctx, config = {}, runtime = {}) {
         held.state.models = spec.models
         held.state.sourceName = spec.sourceName
         try {
-          held.handle.replace([`${provider}-vision`])
+          held.registration.replace([`${provider}-vision`])
           held.key = nextKey
         } catch (error) {
           held.state.models = previousModels
@@ -1394,10 +1393,12 @@ export function apply(ctx, config = {}, runtime = {}) {
       const twinRoute = `${provider}-vision`
       const state = { models: spec.models, sourceName: spec.sourceName }
       try {
-        const handle = ctx.llm.registerAdapter([twinRoute], makeTwinAdapter(provider, state))
-        ctx.effect(() => handle, `vision-router: twin route ${twinRoute}`)
+        const registration = ctx.llm.registerAdapter(
+          [twinRoute],
+          makeTwinAdapter(provider, state),
+        )
         twinHandles.set(provider, {
-          handle,
+          registration,
           state,
           key: twinSpecKey(spec.models, spec.sourceName),
         })
@@ -4666,34 +4667,48 @@ ctx.logger?.info(
     activateDeepTools = () => {
       if (deepActive) return '视觉深看工具已在挂载状态。'
       deepActive = true
-      for (const def of deepToolDefs) {
-        const registeredDef =
-          def.name === 'vision_bootstrap' || typeof def.execute !== 'function'
-            ? def
-            : {
-                ...def,
-                async execute(args, exec) {
-                  const session = exec && exec.agent && exec.agent.session
-                  const state = session ? structuredBootstrapTurnState.get(session) : undefined
-                  if (structuredBootstrapEnabled() && state && state.required && state.completed !== true) {
-                    return JSON.stringify({
-                      ok: false,
-                      code: state.failed ? 'STRUCTURED_BOOTSTRAP_FAILED' : 'STRUCTURED_BOOTSTRAP_REQUIRED',
-                      retryable: !state.failed,
-                      reason: state.failed
-                        ? 'the required structured bootstrap visual pass failed; do not make more visual calls this turn'
-                        : 'call vision_bootstrap and wait for its universal structured visual result before any other vision tool',
-                    })
-                  }
-                  // 识图档位不在这里做调用次数拦截；显式 visionDepthMaxCalls 由
-                  // structured-flow hardening 统一执行，避免与 evidence 完成状态重复计数。
-                  // Tool-specific execution policy belongs to the tool itself; this wrapper owns
-                  // only bootstrap ordering and never rewrites model/user arguments.
-                  const result = await def.execute(args, exec)
-                  return result
-                },
-              }
-        deepDisposers.push(ctx.tools.register(registeredDef))
+      try {
+        for (const def of deepToolDefs) {
+          const registeredDef =
+            def.name === 'vision_bootstrap' || typeof def.execute !== 'function'
+              ? def
+              : {
+                  ...def,
+                  async execute(args, exec) {
+                    const session = exec && exec.agent && exec.agent.session
+                    const state = session ? structuredBootstrapTurnState.get(session) : undefined
+                    if (structuredBootstrapEnabled() && state && state.required && state.completed !== true) {
+                      return JSON.stringify({
+                        ok: false,
+                        code: state.failed ? 'STRUCTURED_BOOTSTRAP_FAILED' : 'STRUCTURED_BOOTSTRAP_REQUIRED',
+                        retryable: !state.failed,
+                        reason: state.failed
+                          ? 'the required structured bootstrap visual pass failed; do not make more visual calls this turn'
+                          : 'call vision_bootstrap and wait for its universal structured visual result before any other vision tool',
+                      })
+                    }
+                    // 识图档位不在这里做调用次数拦截；显式 visionDepthMaxCalls 由
+                    // structured-flow hardening 统一执行，避免与 evidence 完成状态重复计数。
+                    // Tool-specific execution policy belongs to the tool itself; this wrapper owns
+                    // only bootstrap ordering and never rewrites model/user arguments.
+                    const result = await def.execute(args, exec)
+                    return result
+                  },
+                }
+          deepDisposers.push(ctx.tools.register(registeredDef))
+        }
+      } catch (error) {
+        // A partial mount must never be reported as mounted: retire what this
+        // attempt registered, release the latch and surface the failure.
+        deepDisposers.splice(0).forEach((dispose) => {
+          try {
+            dispose()
+          } catch {
+            // Rollback is best effort; the original registration error wins.
+          }
+        })
+        deepActive = false
+        throw error
       }
       return (
         '视觉深看工具已挂载：vision_bootstrap（结构化预识别）、vision_describe（看图问答）、vision_ground（像素定位）、vision_detect（元素清单）、' +
@@ -4703,20 +4718,32 @@ ctx.logger?.info(
         '注意：vision_ocr 只用于读取图片文字；视觉工具返回 ok:false 后端不可用结果时，不要改问法重复调用，继续文本任务。'
       )
     }
+    ctx.effect(
+      () => () => {
+        deepDisposers.splice(0).forEach((dispose) => dispose())
+        deepActive = false
+      },
+      'vision-router: deep tools',
+    )
+
     if (progressive) {
-      ctx.tools.register({
-        name: 'vision_activate',
-        description:
-          'Mount the deep vision tools (vision_bootstrap / vision_describe / vision_ground / vision_detect / vision_materialize / vision_crop / ' +
-          'vision_pixel_diff / vision_colors / vision_ocr / vision_trace / ' +
-          'vision_extract_foreground / vision_present / vision_html_screenshot) for this session. Desktop screenshot remains disabled until the user explicitly opts in through Vision Router settings. They mount ' +
-          'automatically on image turns; call this only when you need them on a text-only turn.',
-        parameters: { type: 'object', properties: {}, additionalProperties: false },
-        output: stringOutput,
-        async execute() {
-          return activateDeepTools()
-        },
-      })
+      ctx.effect(
+        () =>
+          ctx.tools.register({
+            name: 'vision_activate',
+            description:
+              'Mount the deep vision tools (vision_bootstrap / vision_describe / vision_ground / vision_detect / vision_materialize / vision_crop / ' +
+              'vision_pixel_diff / vision_colors / vision_ocr / vision_trace / ' +
+              'vision_extract_foreground / vision_present / vision_html_screenshot) for this session. Desktop screenshot remains disabled until the user explicitly opts in through Vision Router settings. They mount ' +
+              'automatically on image turns; call this only when you need them on a text-only turn.',
+            parameters: { type: 'object', properties: {}, additionalProperties: false },
+            output: stringOutput,
+            async execute() {
+              return activateDeepTools()
+            },
+          }),
+        'vision-router: progressive bootstrap tool',
+      )
       const skills = ctx.get('skills')
       if (skills !== undefined && typeof skills.register === 'function') {
         ctx.effect(
@@ -4767,13 +4794,6 @@ ctx.logger?.info(
     } else {
       activateDeepTools()
     }
-    ctx.effect(
-      () => () => {
-        deepDisposers.splice(0).forEach((dispose) => dispose())
-        deepActive = false
-      },
-      'vision-router: deep tools',
-    )
   }
 
   // ── settings seam: the Web 设置 > 插件 > 插件配置 panel owns a
@@ -4784,6 +4804,9 @@ ctx.logger?.info(
   // @deepseek-ai/dsh-settings: the published npm build trails the deployment,
   // and the service API is the stable contract here.
   ctx.inject(['settings'], (sctx) => {
+    // Registration and the live-settings subscription are Host contract calls:
+    // they must happen for every supported Host, independently of whether the
+    // lifecycle seam below can run eagerly. Only ownership needs the factory.
     const scope = sctx.settings.register('vision-router', Config, {
       base: config,
     })
@@ -4791,26 +4814,43 @@ ctx.logger?.info(
     // With the settings document now visible, reconcile the routing mounts
     // (wrapper route, chain route) against the resolved values.
     syncRoutingMounts()
-    sctx.effect(
-      () => () => {
-        // The settings provider went away: fall back to the composition entry.
-        current = () => config
-      },
-      'vision-router: settings fallback',
-    )
-    scope.watch(() => {
-      // Most consumers read current() per call, but the wrappedProviders
-      // twins and the routing mounts are registered eagerly: re-sync them
-      // whenever the settings document loads or the user edits the card.
-      syncTwins()
-      syncRoutingMounts()
-    })
+    let disposeWatch
+    if (typeof scope.watch === 'function') {
+      disposeWatch = scope.watch(() => {
+        // Most consumers read current() per call, but the wrappedProviders
+        // twins and the routing mounts are registered eagerly: re-sync them
+        // whenever the settings document loads or the user edits the card.
+        syncTwins()
+        syncRoutingMounts()
+      })
+    }
+    const restore = () => {
+      if (typeof disposeWatch === 'function') disposeWatch()
+      disposeWatch = undefined
+      // The settings provider went away: fall back to the composition entry.
+      current = () => config
+    }
+    if (typeof sctx.effect !== 'function') {
+      // No lifecycle seam: this injection's context owns the source, so there is
+      // nothing for DVR to restore when the Settings service itself goes away.
+      return
+    }
+    try {
+      sctx.effect(() => restore, 'vision-router: settings source')
+    } catch (error) {
+      // Registration already published the scope and its subscription: withdraw
+      // both before the failure escapes, exactly as the owner would on unload.
+      restore()
+      throw error
+    }
   })
 
   // Product diagnostics/settings support is a separate Web owner. Core supplies
   // only the three coherent domain faces it already computes; route lifecycle,
   // bounded /models probing and JSON response semantics live outside Core.
   installVisionDiagnosticsRoutes(ctx, {
+    // Same egress as real vision turns: the Router-owned provider transport.
+    transport: runtime?.providerTransport,
     connection: {
       candidatePairs: pairs,
       localBackends: () => localProvidersOf(current()),
@@ -4836,7 +4876,7 @@ ctx.logger?.info(
   // (plus a fixed product allowlist) — without this directory entry the Web
   // card's settingsScope binder reports the namespace as unavailable.
   try {
-    const providerDirectory = ctx.llm.registerConfigurableProviders([
+    ctx.llm.registerConfigurableProviders([
       {
         provider: 'vision-router',
         displayName: '视觉路由（自动识图）',
@@ -4844,7 +4884,6 @@ ctx.logger?.info(
         settingsPath: [],
       },
     ])
-    ctx.effect(() => providerDirectory, 'vision-router: configurable provider directory')
   } catch (error) {
     ctx.logger?.warn(
       'vision-router: configurable provider registration failed: %s',

package/lib/agent-request-route-authority.js

@@ -1,8 +1,6 @@
 import { projectDelegatedCallConfig } from './delegated-call-config.js'
 import { contextWithTwinImageCapabilityFallback } from './twin-image-capability-fallback.js'
 
-const routeAuthorityOptionsByContext = new WeakMap()
-
 function isObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value)
 }
@@ -30,21 +28,6 @@ export function projectAgentRequestRouteHandoff(sourceConfig, resultConfig) {
   return projectDelegatedCallConfig(resultConfig)
 }
 
-/**
- * Runtime composition can publish route identities before Core.apply without
- * changing the mature `contextWithAgentRequestRouteAuthority(backendRuntimeCtx)`
- * boundary shape. The WeakMap keeps this per-context and garbage-collectable.
- */
-export function configureAgentRequestRouteAuthority(ctx, options = {}) {
-  if (!isObject(ctx)) return ctx
-  routeAuthorityOptionsByContext.set(ctx, {
-    wrapperRoute: options.wrapperRoute,
-    chainRoute: options.chainRoute,
-    logger: options.logger,
-  })
-  return ctx
-}
-
 /**
  * Private Core-facing context. It wraps only `agent/request` handlers and only
  * projects a result when that handler demonstrably changed provider/model.
@@ -60,9 +43,7 @@ export function configureAgentRequestRouteAuthority(ctx, options = {}) {
  */
 export function contextWithAgentRequestRouteAuthority(ctx, options) {
   if (!isObject(ctx)) return ctx
-  const fallbackOptions = isObject(options)
-    ? options
-    : routeAuthorityOptionsByContext.get(ctx) ?? {}
+  const fallbackOptions = isObject(options) ? options : {}
   const routeAuthorityCtx = new Proxy(ctx, {
     get(target, property) {
       if (property !== 'on') {

package/lib/core-apply-lifecycle.js

@@ -1,47 +1,41 @@
-/**
- * Preserve Core's synchronous apply contract while giving Promise-like Core
- * implementations one explicit settlement boundary for post-registration work.
- * This helper owns no runtime state; callers provide success/failure lifecycle
- * effects explicitly.
- */
 export function runCoreApplyLifecycle(invoke, { onSuccess, onFailure } = {}) {
-  if (typeof invoke !== 'function') throw new TypeError('Core apply lifecycle requires an invoke function')
-  const succeed = typeof onSuccess === 'function' ? onSuccess : () => {}
-  const fail = (error) => {
-    try {
-      onFailure?.(error)
-    } catch {
-      // Cleanup/diagnostic failure must not replace the Core apply error.
-    }
-    throw error
-  }
-
-  let result
-  try {
-    result = invoke()
-  } catch (error) {
-    return fail(error)
-  }
-
-  if (result && typeof result.then === 'function') {
-    return Promise.resolve(result).then(
-      (value) => {
+    if (typeof invoke !== 'function')
+        throw new TypeError('Core apply lifecycle requires an invoke function');
+    const succeed = typeof onSuccess === 'function' ? onSuccess : () => { };
+    const fail = (error) => {
         try {
-          succeed()
-          return value
-        } catch (error) {
-          return fail(error)
+            onFailure?.(error);
+        }
+        catch {
+            // Cleanup/diagnostic failure must not replace the Core apply error.
         }
-      },
-      fail,
-    )
-  }
-
-  try {
-    succeed()
-    return result
-  } catch (error) {
-    return fail(error)
-  }
+        throw error;
+    };
+    let result;
+    try {
+        result = invoke();
+    }
+    catch (error) {
+        return fail(error);
+    }
+    if (result !== null
+        && (typeof result === 'object' || typeof result === 'function')
+        && typeof result.then === 'function') {
+        return Promise.resolve(result).then((value) => {
+            try {
+                succeed();
+                return value;
+            }
+            catch (error) {
+                return fail(error);
+            }
+        }, fail);
+    }
+    try {
+        succeed();
+        return result;
+    }
+    catch (error) {
+        return fail(error);
+    }
 }
-

package/lib/core-cache.js

@@ -0,0 +1,87 @@
+export function cacheWeight(value) {
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array)
+        return value.byteLength;
+    if (typeof value === 'string')
+        return Buffer.byteLength(value, 'utf8');
+    try {
+        const encoded = JSON.stringify(value);
+        return Buffer.byteLength(encoded === undefined ? String(value) : encoded, 'utf8');
+    }
+    catch {
+        return Buffer.byteLength(String(value), 'utf8');
+    }
+}
+/**
+ * LRU+TTL cache bounded by both entry count and retained bytes.
+ *
+ * Keys are normalized to strings at the ownership boundary. A rejected write
+ * never remains resident, and every eviction updates retained-byte accounting
+ * before the entry is released.
+ */
+export function createCache(maxEntries, ttlMsValue, options = {}) {
+    const entries = new Map();
+    const entryLimit = Math.max(0, Math.floor(Number(maxEntries) || 0));
+    const ttlMs = ttlMsValue;
+    const maxBytes = Number.isFinite(Number(options.maxBytes)) && Number(options.maxBytes) >= 0
+        ? Math.floor(Number(options.maxBytes))
+        : 8 * 1024 * 1024;
+    const maxEntryBytes = Number.isFinite(Number(options.maxEntryBytes)) && Number(options.maxEntryBytes) >= 0
+        ? Math.floor(Number(options.maxEntryBytes))
+        : Math.min(maxBytes, 1024 * 1024);
+    let retainedBytes = 0;
+    const remove = (key) => {
+        const entry = entries.get(key);
+        if (entry === undefined)
+            return;
+        retainedBytes = Math.max(0, retainedBytes - entry.weight);
+        entries.delete(key);
+    };
+    const evict = () => {
+        while (entries.size > entryLimit || retainedBytes > maxBytes) {
+            const oldest = entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            remove(oldest);
+        }
+    };
+    return {
+        get(key) {
+            const rawKey = key;
+            const entry = entries.get(rawKey);
+            if (entry === undefined)
+                return undefined;
+            if (entry.expiresAt <= Date.now()) {
+                remove(rawKey);
+                return undefined;
+            }
+            entries.delete(rawKey);
+            entries.set(rawKey, entry);
+            return entry.value;
+        },
+        set(key, value) {
+            const normalizedKey = String(key);
+            const weight = Buffer.byteLength(normalizedKey, 'utf8') + cacheWeight(value);
+            remove(normalizedKey);
+            if (entryLimit === 0
+                || maxBytes === 0
+                || weight > maxEntryBytes
+                || weight > maxBytes) {
+                return false;
+            }
+            entries.set(normalizedKey, {
+                value,
+                weight,
+                expiresAt: ttlMs <= 0 ? Infinity : Date.now() + ttlMs,
+            });
+            retainedBytes += weight;
+            evict();
+            return entries.has(normalizedKey);
+        },
+        get size() {
+            return entries.size;
+        },
+        get bytes() {
+            return retainedBytes;
+        },
+    };
+}

package/lib/core-primitives.js

@@ -611,77 +611,7 @@ export function extractJson(text) {
   return undefined
 }
 
-function cacheWeight(value) {
-  if (Buffer.isBuffer(value) || value instanceof Uint8Array) return value.byteLength
-  if (typeof value === 'string') return Buffer.byteLength(value, 'utf8')
-  try {
-    const encoded = JSON.stringify(value)
-    return Buffer.byteLength(encoded === undefined ? String(value) : encoded, 'utf8')
-  } catch {
-    return Buffer.byteLength(String(value), 'utf8')
-  }
-}
-
-/** LRU+TTL cache bounded by BOTH entry count and retained bytes. */
-export function createCache(maxEntries, ttlMs, options = {}) {
-  const entries = new Map()
-  const entryLimit = Math.max(0, Math.floor(Number(maxEntries) || 0))
-  const maxBytes = Number.isFinite(Number(options.maxBytes)) && Number(options.maxBytes) >= 0
-    ? Math.floor(Number(options.maxBytes))
-    : 8 * 1024 * 1024
-  const maxEntryBytes = Number.isFinite(Number(options.maxEntryBytes)) && Number(options.maxEntryBytes) >= 0
-    ? Math.floor(Number(options.maxEntryBytes))
-    : Math.min(maxBytes, 1024 * 1024)
-  let retainedBytes = 0
-
-  const remove = (key) => {
-    const entry = entries.get(key)
-    if (!entry) return
-    retainedBytes = Math.max(0, retainedBytes - entry.weight)
-    entries.delete(key)
-  }
-  const evict = () => {
-    while (entries.size > entryLimit || retainedBytes > maxBytes) {
-      const oldest = entries.keys().next().value
-      if (oldest === undefined) break
-      remove(oldest)
-    }
-  }
-
-  return {
-    get(key) {
-      const entry = entries.get(key)
-      if (!entry) return undefined
-      if (entry.expiresAt <= Date.now()) {
-        remove(key)
-        return undefined
-      }
-      entries.delete(key)
-      entries.set(key, entry)
-      return entry.value
-    },
-    set(key, value) {
-      const normalizedKey = String(key)
-      const weight = Buffer.byteLength(normalizedKey, 'utf8') + cacheWeight(value)
-      remove(normalizedKey)
-      if (entryLimit === 0 || maxBytes === 0 || weight > maxEntryBytes || weight > maxBytes) return false
-      entries.set(normalizedKey, {
-        value,
-        weight,
-        expiresAt: ttlMs <= 0 ? Infinity : Date.now() + ttlMs,
-      })
-      retainedBytes += weight
-      evict()
-      return entries.has(normalizedKey)
-    },
-    get size() {
-      return entries.size
-    },
-    get bytes() {
-      return retainedBytes
-    },
-  }
-}
+export { cacheWeight, createCache } from './core-cache.js'
 
 /** True when the harness llm service has a registered adapter for the provider route. */
 export function adapterAvailable(llm, provider) {
@@ -2007,7 +1937,11 @@ async function callLmStudioNative(provider, messages, options = {}) {
     ...(typeof options.temperature === 'number' ? { temperature: options.temperature } : {}),
     ...(typeof options.top_p === 'number' ? { top_p: options.top_p } : {}),
   }
-  const response = await fetch(`${apiRoot}/api/v1/chat`, {
+  const transport = options.providerTransport
+  const requestFetch = typeof transport?.fetch === 'function'
+    ? (input, init) => transport.fetch(input, init, { providerName: provider.name, allowProxy: true })
+    : fetch
+  const response = await requestFetch(`${apiRoot}/api/v1/chat`, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
     body: JSON.stringify(body),
@@ -2054,6 +1988,9 @@ export async function callLocalBackend(provider, messages, options = {}) {
     return callLmStudioNative(provider, messages, {
       maxTokens,
       signal: options.signal,
+      // The native LM Studio transport is a provider leg like the openai/anthropic
+      // ones: it must use the Router-owned transport so proxy/proxyHosts apply.
+      providerTransport: options.providerTransport,
       ...(typeof provider.reasoningEffort === 'string' ? { reasoningEffort: provider.reasoningEffort } : {}),
       ...sampling,
     })
@@ -2335,77 +2272,8 @@ export async function callOpenAICompatible(provider, messages, options = {}) {
   return text
 }
 
-/**
- * Minimal harness-chunk assembler (no dsh imports required). Feeds the raw
- * `llm/stream` chunk protocol and produces the final text of text blocks.
- * Terminal failures throw; a `max-tokens` finish returns the partial text.
- */
-export function createChunkAssembler() {
-  const parts = new Map()
-  const order = []
-  let finishKind
-  let failure
-
-  const push = (chunk) => {
-    if (!chunk || typeof chunk.type !== 'string') return
-    switch (chunk.type) {
-      case 'block-start': {
-        if (!parts.has(chunk.index)) {
-          order.push(chunk.index)
-          parts.set(chunk.index, { type: chunk.blockType, text: '' })
-        }
-        break
-      }
-      case 'text-delta': {
-        const part = parts.get(chunk.index)
-        if (part) part.text += chunk.text ?? ''
-        break
-      }
-      case 'reasoning-delta':
-      case 'tool-call-delta':
-      case 'usage':
-        break
-      case 'block-end': {
-        const part = parts.get(chunk.index)
-        if (part && chunk.block && typeof chunk.block.text === 'string') {
-          part.text = chunk.block.text
-        }
-        break
-      }
-      case 'finish': {
-        const reason = chunk.reason
-        if (reason && (reason.kind === 'error' || reason.kind === 'aborted')) {
-          failure = reason.failure
-        }
-        finishKind = reason && reason.kind ? reason.kind : 'stop'
-        break
-      }
-      case 'error':
-      case 'aborted':
-        failure = chunk.failure
-        break
-      default:
-        break
-    }
-  }
-
-  const finish = () => {
-    if (failure) {
-      throw new Error(failure && failure.message ? failure.message : String(failure))
-    }
-    if (finishKind !== undefined && finishKind !== 'stop' && finishKind !== 'max-tokens') {
-      throw new Error(`vision call finished with "${finishKind}"`)
-    }
-    return order
-      .map((index) => parts.get(index))
-      .filter((part) => part && part.type === 'text')
-      .map((part) => part.text)
-      .join('')
-      .trim()
-  }
-
-  return { push, finish }
-}
+import { createChunkAssembler } from './vision-chunk-assembler.js'
+export { createChunkAssembler }
 
 async function visionAnswer(llm, options) {
   return runWithVisionSessionAffinity(options?.sessionId, async () => {
@@ -2972,7 +2840,6 @@ export {
   FAILURE_ADVICE,
   PERSISTED_GUARD_STOP_SURFACE_ID,
   imageMarker,
-  cacheWeight,
   visionAnswer,
   NON_GENERATIVE_VISION_MODEL_HINTS,
   VISION_MODEL_NAME_HINTS,