dsh-vision-router 2.1.5 → 2.1.7

package/index.js

@@ -12,9 +12,10 @@
 // are downscaled with sharp, results are cached by content hash + question,
 // and an optional JSON mode validates structured output.
 //
-// Proxy: an optional `proxy` config (e.g. http://127.0.0.1:10808) patches the
-// process fetch to route only the `proxyHosts` domains through it; everything
-// else (DeepSeek and the rest) stays on the direct connection.
+// Proxy: network egress is Host-owned by default. A blank `proxy` leaves fetch
+// entirely on DSH/Host's current network path. An explicit plugin proxy is an
+// advanced vision-only override for `proxyHosts`; Host-owned visual adapters use
+// a scoped compatibility wrapper, never configuration-wide process routing.
 
 // Compatibility shim: dsh 0.1.2-alpha.4 removed `session.events` in favor of
 // `session.snapshotEvents()`. This helper returns an array (or undefined) that
@@ -105,6 +106,7 @@ import {
 } from './lib/http-body-limit.js'
 import { writeArtifactFile } from './lib/artifact-boundary.js'
 import { stripTrailingSlashes } from './lib/string-normalization.js'
+import { streamWithLegacyGlobalProxyScope } from './lib/legacy-global-proxy-boundary.js'
 import { parseVersionComparator } from './lib/version-range.js'
 import { createCoalescingRunner } from './lib/adapter-update-coalescer.js'
 import { captureWindowsDesktop } from './lib/windows-desktop-capture.js'
@@ -1129,8 +1131,8 @@ export function apply(ctx, config = {}, runtime = {}) {
   // session model does not declare image input, and the DeepSeek adapter
   // hardcodes text-only. This wrapper route (`deepseek-vision` by default)
   // declares image input so the admission passes, shows up in the model
-  // picker as "DeepSeek + 自动识图", and delegates to the real text-provider
-  // adapter for anything the waterfalls did not rewrite.
+  // picker as "DeepSeek + 自动识图", and delegates only to the official
+  // DeepSeek adapter (or the hidden native route during stealth takeover).
   //
   // The adapter is built unconditionally; whether (and under which name) it
   // mounts is reconciled reactively against the resolved settings document by
@@ -1138,12 +1140,16 @@ export function apply(ctx, config = {}, runtime = {}) {
   // take effect without a restart.
   let wrapperAdapter
   {
-    const WRAPPER_MODEL_IDS = ['deepseek-v4-pro', 'deepseek-v4-flash']
     const wrapName = (name) => name ?? 'DeepSeek'
-    const textProviderRoute = () => (stealthActive ? nativeRoute : textProvider().provider)
+    // The row is explicitly branded as DeepSeek, so its metadata and network
+    // authority must come from DeepSeek as well. `textProvider` is legacy
+    // configuration and must never let an arbitrary relay masquerade behind
+    // the special wrapper. During stealth takeover old wrapper sessions keep
+    // delegating to the hidden native DeepSeek route.
+    const wrapperDelegateRoute = () => (stealthActive ? nativeRoute : 'deepseek-official')
     const delegateAdapter = () => {
       try {
-        return ctx.llm.registration(textProviderRoute()).adapter
+        return ctx.llm.registration(wrapperDelegateRoute()).adapter
       } catch {
         return undefined
       }
@@ -1154,7 +1160,7 @@ export function apply(ctx, config = {}, runtime = {}) {
       },
       providerRetryPolicy() {
         try {
-          return ctx.llm.registration(textProviderRoute()).retryPolicy
+          return ctx.llm.registration(wrapperDelegateRoute()).retryPolicy
         } catch {
           return undefined
         }
@@ -1165,12 +1171,12 @@ export function apply(ctx, config = {}, runtime = {}) {
         if (stealthActive) return []
         const entries = []
         const real = delegateAdapter()
-        if (real !== undefined) {
+        if (real !== undefined && typeof real.listModels === 'function') {
           try {
-            const listed = await real.listModels(textProviderRoute())
+            const listed = await real.listModels('deepseek-official')
             entries.push(
-              ...listed
-                .filter((model) => WRAPPER_MODEL_IDS.includes(model.id))
+              ...(Array.isArray(listed) ? listed : [])
+                .filter((model) => model && typeof model.id === 'string' && model.id !== '')
                 .map((model) => ({
                   ...model,
                   provider: wrapperRoute(),
@@ -1219,14 +1225,29 @@ export function apply(ctx, config = {}, runtime = {}) {
               inputModalities: ['text', 'image'],
             }
           } catch {
-            /* fall through to the text-provider path */
+            /* fall through to the official DeepSeek path */
           }
         }
         const real = delegateAdapter()
-        if (real === undefined) {
-          throw new Error('vision-router: the text provider adapter is not available')
+        if (real === undefined || typeof real.resolveModel !== 'function') {
+          throw new Error('vision-router: the official DeepSeek adapter is not available')
         }
-        const base = await real.resolveModel(textProviderRoute(), model)
+        // Outside stealth mode, accept only models the live official catalog
+        // actually publishes. Some adapters can resolve arbitrary ids; that is
+        // not permission to expose them under the DeepSeek product identity.
+        if (!stealthActive) {
+          if (typeof real.listModels !== 'function') {
+            throw new Error('vision-router: the official DeepSeek catalog is not available')
+          }
+          const listed = await real.listModels('deepseek-official')
+          const admitted = Array.isArray(listed) && listed.some(
+            (entry) => entry && entry.id === model,
+          )
+          if (!admitted) {
+            throw new Error(`vision-router: DeepSeek model "${model}" is not in the live official catalog`)
+          }
+        }
+        const base = await real.resolveModel(wrapperDelegateRoute(), model)
         return {
           ...base,
           provider: wrapperRoute(),
@@ -1236,7 +1257,7 @@ export function apply(ctx, config = {}, runtime = {}) {
       },
       ...createWrapperStreamBody(ctx, {
         imageMemory,
-        delegateProvider: textProviderRoute(),
+        delegateProvider: wrapperDelegateRoute,
         instantLocal: instantLocalProvider,
         instantLocalStyle,
         instantLocalTimeoutMs: timeoutMs,
@@ -1765,7 +1786,15 @@ export function apply(ctx, config = {}, runtime = {}) {
     const corrected = await correctedVisionAnswer(pair, messages, options)
     if (corrected !== undefined) return corrected
     assertOpenCodeGoAffinityForPair(pair, options.sessionId)
-    return visionAnswer(ctx.llm, {
+    return visionAnswer({
+      stream(streamOptions) {
+        return streamWithLegacyGlobalProxyScope(
+          pair.provider,
+          pair.model,
+          () => ctx.llm.stream(streamOptions),
+        )
+      },
+    }, {
       provider: pair.provider,
       model: pair.model,
       messages,
@@ -2079,14 +2108,18 @@ export function apply(ctx, config = {}, runtime = {}) {
               })
               if (text === undefined) {
                 assertOpenCodeGoAffinityForPair(pair, options.sessionId)
-                yield* streamWithVisionSessionAffinity(options.sessionId, () => ctx.llm.stream({
-                  ...options,
-                  provider: pair.provider,
-                  model: pair.model,
-                  reasoningEffort: undefined,
-                  messages,
-                  signal: attemptSignal,
-                }))
+                yield* streamWithLegacyGlobalProxyScope(
+                  pair.provider,
+                  pair.model,
+                  () => streamWithVisionSessionAffinity(options.sessionId, () => ctx.llm.stream({
+                    ...options,
+                    provider: pair.provider,
+                    model: pair.model,
+                    reasoningEffort: undefined,
+                    messages,
+                    signal: attemptSignal,
+                  })),
+                )
                 return
               }
               if (text !== '') {
@@ -2227,73 +2260,8 @@ export function apply(ctx, config = {}, runtime = {}) {
   // #208: attachment refs, description memory and the event-log cursor are
   // owned by the same bounded SessionVisionStateStore above.
 
-  // ── optional fetch proxy for the vision provider hosts ─────────────────────
-  //
-  // Resolved per request from the live settings section (`current()`), so the
-  // Web settings panel can change the proxy URL and host list without a
-  // restart. The fetch patcher itself is installed once for the plugin fiber.
-
-  const currentProxyUrl = () => {
-    const value = current().proxy
-    return typeof value === 'string' && value !== '' ? value : undefined
-  }
-  const currentProxyHosts = () => {
-    const value = current().proxyHosts
-    return Array.isArray(value)
-      ? value.filter((host) => typeof host === 'string' && host !== '')
-      : []
-  }
-
-  {
-    const originalFetch = globalThis.fetch
-    let cachedAgentUrl
-    let cachedAgentPromise
-    const agentFor = (url) => {
-      if (cachedAgentUrl === url && cachedAgentPromise !== undefined) return cachedAgentPromise
-      cachedAgentUrl = url
-      // Do not import userland Undici at plugin/module load time. Loading a
-      // different Undici major can disturb the dispatcher used by the host's
-      // built-in fetch even when Vision Router's own proxy setting is empty.
-      // Load ProxyAgent only when this plugin's selective proxy is actually used.
-      cachedAgentPromise = import('undici')
-        .then(({ ProxyAgent }) => {
-          if (typeof ProxyAgent !== 'function') {
-            throw new Error('dsh-vision-router: undici ProxyAgent is unavailable')
-          }
-          return new ProxyAgent(url)
-        })
-        .catch((error) => {
-          if (cachedAgentUrl === url) {
-            cachedAgentUrl = undefined
-            cachedAgentPromise = undefined
-          }
-          throw error
-        })
-      return cachedAgentPromise
-    }
-    const patchedFetch = (input, init) => {
-      const proxyUrl = currentProxyUrl()
-      if (proxyUrl === undefined) return originalFetch(input, init)
-      let url
-      try {
-        url = new URL(
-          typeof input === 'string' ? input : input && input.url ? input.url : String(input),
-        )
-      } catch {
-        return originalFetch(input, init)
-      }
-      if (!hostMatchesAny(url.hostname, currentProxyHosts())) return originalFetch(input, init)
-      return agentFor(proxyUrl).then((dispatcher) =>
-        originalFetch(input, { ...(init ?? {}), dispatcher }),
-      )
-    }
-    ctx.effect(() => {
-      globalThis.fetch = patchedFetch
-      return () => {
-        globalThis.fetch = originalFetch
-      }
-    }, 'vision-router: proxy fetch')
-  }
+  // Host-owned proxy overrides are scoped by lib/legacy-global-proxy-boundary.js.
+  // Core no longer owns or installs a process-wide proxy fetch implementation.
 
   const lookupAttachment = (session, id) => sessionVisionIndex.lookupAttachment(session, id)
 

package/lib/adversarial-hardening.js

@@ -470,52 +470,6 @@ export function installAdversarialHardening(ctx, config = {}, core) {
   const wrapped = new Proxy(ctx, {
     get(target, property) {
       if (property === 'tools') return wrapTools(target.tools, wrapped, core, hardenedConfig)
-      if (property === 'effect') {
-        const effect = Reflect.get(target, property, target)
-        if (typeof effect !== 'function') return effect
-        return (factory, label) => {
-          if (label !== 'vision-router: proxy fetch') return effect.call(target, factory, label)
-          return effect.call(target, () => {
-            const originalFetch = globalThis.fetch
-            const disposer = factory()
-            let installedFetch = globalThis.fetch
-            let active = true
-            // Later plugins may capture this function. Making it an inert
-            // delegator on unload removes Vision Router from the chain even if
-            // another plugin still sits above it, and prevents it resurfacing
-            // when that later plugin restores the fetch value it captured.
-            const guardedFetch = (...args) => {
-              const fetchImpl = active && typeof installedFetch === 'function'
-                ? installedFetch
-                : originalFetch
-              return fetchImpl(...args)
-            }
-            globalThis.fetch = guardedFetch
-            return () => {
-              if (!active) return
-              active = false
-              // Drop the raw Vision Router fetch closure as soon as ownership
-              // ends. This releases its cached ProxyAgent/undici closure even
-              // when a later plugin still retains guardedFetch.
-              installedFetch = undefined
-              const currentFetch = globalThis.fetch
-              try {
-                // Always run the underlying effect disposer. It may own more
-                // than the process-level pointer; skipping it merely because a
-                // later plugin wrapped fetch leaks that lifecycle forever.
-                if (typeof disposer === 'function') disposer()
-              } finally {
-                // The core disposer currently restores originalFetch
-                // unconditionally. Preserve any later plugin that was above us,
-                // while an outermost Vision Router cleanup returns to the host.
-                globalThis.fetch = currentFetch === guardedFetch
-                  ? originalFetch
-                  : currentFetch
-              }
-            }
-          }, label)
-        }
-      }
       // Deliberately do NOT wrap ctx.inject or injected child contexts. DSH
       // rc.6 ties route/effect ownership to the exact child-context identity;
       // replacing it with a Proxy previously made host routes disappear (#160).