dsh-vision-router 2.2.8 → 3.0.0

package/lib/runtime-composition.js

@@ -14,8 +14,12 @@ import { contextWithNativeImageCoexistence } from './native-image-coexistence.js
 import { createCoreVisionSurfaceRuntime } from './core-vision-surface.js'
 import { installSessionVisionIndexBoundary } from './session-vision-index.js'
 import { createSessionVisionRuntime } from './session-vision-runtime.js'
+import { runCoreApplyLifecycle } from './core-apply-lifecycle.js'
 import { installLegacyCoreVisionPolicyBridge } from './legacy-core-vision-policy-bridge.js'
 import { installSessionVisionModeBoundary } from './session-vision-mode-boundary.js'
+import { resolveSessionVisionModeAuthority } from './session-vision-mode-authority.js'
+import { createSessionVisionPolicyRuntimeStore } from './session-vision-policy-domain.js'
+import { installSessionVisionDelegationBoundary } from './session-vision-delegation-boundary.js'
 import { installPiAiBridgeWireCompat } from './pi-ai-bridge-wire-compat.js'
 import { installLiveModelDiscovery } from './live-model-discovery.js'
 import { installVisionModelRegistry } from './vision-model-registry.js'
@@ -23,14 +27,12 @@ import { installAdversarialHardening } from './adversarial-hardening.js'
 import { installOllamaColdStartGuard } from './ollama-cold-start.js'
 import { installLocalVisionStabilizer } from './local-vision-stabilizer.js'
 import { installWrapperDirectoryAlias } from './wrapper-directory.js'
-import { installAndroidAttachmentCompat } from './android-attachment-compat.js'
 import { contextWithCoalescedAdapterUpdates } from './adapter-update-coalescer.js'
 import { installTesseractExecFileCompat } from './tesseract-exec-compat.js'
 import { installLocalMutationRouteBoundary } from './web-capability-boundary.js'
 import { installScreenshotSourceBoundary } from './screenshot-source-boundary.js'
 import { installVisionToolRuntimeBoundary } from './vision-tool-runtime-boundary.js'
 import {
-  configureAgentRequestRouteAuthority,
   contextWithAgentRequestRouteAuthority,
 } from './agent-request-route-authority.js'
 import { contextWithGroundingCoordinateFrame } from './grounding-coordinate-runtime.js'
@@ -57,7 +59,7 @@ import {
 } from './structured-flow-hardening.js'
 import { installVisionLimitDiagnostics } from './vision-limit-diagnostics.js'
 import {
-  attachmentContextForContract,
+  installDshHostCapabilityDiagnostics,
   createSessionEventReader,
   createSessionEventTailReader,
   createSessionLogReader,
@@ -73,6 +75,7 @@ import {
 } from './web/index.js'
 import { createRuntimeI18nCoreFacade } from './runtime-i18n-core.js'
 import { createRuntimeI18nCoreScope } from './runtime-i18n-core-scope.js'
+import { installVisionMaintenanceRoutes } from './maintenance-routes.js'
 
 function liveVisionSettings(ctx, fallback) {
   try {
@@ -95,7 +98,7 @@ function legacyCoreVisionSettings(ctx, fallback) {
   return { ...current, autoActivateOnImage: false }
 }
 
-export function applyVisionRuntimeComposition(ctx, config = {}, core) {
+function installHostAndSecurityBoundaries(ctx, config, core) {
   // SessionVisionIndex calls planGuardStopShadows before Core.apply. Keep that
   // one helper behind the live-locale facade; the final Core itself still gets
   // the ordinary composition identity and is localized by the scoped context.
@@ -134,7 +137,9 @@ export function applyVisionRuntimeComposition(ctx, config = {}, core) {
     config,
     core,
   )
-  const ollamaColdStartCtx = installOllamaColdStartGuard(hardenedCtx, hardenedConfig, core)
+  const ollamaColdStartCtx = installOllamaColdStartGuard(hardenedCtx, hardenedConfig, core, {
+    logger: logging.logger,
+  })
   const { ctx: stabilizedCtx, bootConfig } = installLocalVisionStabilizer(
     ollamaColdStartCtx,
     hardenedConfig,
@@ -174,10 +179,29 @@ export function applyVisionRuntimeComposition(ctx, config = {}, core) {
         Config: core.Config,
       })
     : ownershipCtx
-  const attachmentCompatCtx = attachmentContextForContract(settingsCtx, logging.logger, {
-    installAndroidAttachmentCompat,
-  })
+  // DVR 2.3 supports DSH from the 0.1.5 train, whose attachment
+  // contract already owns batch persistence. The old no-batch Android wrapper
+  // is therefore unreachable; keep capability diagnostics as an explicit
+  // composition responsibility instead of hiding that side effect in a shim.
+  installDshHostCapabilityDiagnostics(settingsCtx)
+  const attachmentCompatCtx = settingsCtx
 
+  return {
+    attachmentCompatCtx,
+    batchAttachmentHost,
+    capabilityStore,
+    hardenedConfig,
+    hostOwnsOfficialDeepSeek,
+    logging,
+    runtimeConfig,
+    runtimeI18nCore,
+    runtimeI18nCoreScope,
+    runtimePerformanceStore,
+  }
+}
+
+function createRuntimeOwners(host, core) {
+  const { attachmentCompatCtx, logging, runtimeConfig, runtimeI18nCore } = host
   const toolRuntimeCtx = installVisionToolRuntimeBoundary(attachmentCompatCtx, runtimeConfig)
   const nativeImageCompat = contextWithNativeImageCoexistence(toolRuntimeCtx, runtimeConfig)
   const coreVisionSurfaceRuntime = createCoreVisionSurfaceRuntime({
@@ -208,11 +232,37 @@ export function applyVisionRuntimeComposition(ctx, config = {}, core) {
     nativeImageCompat.config,
     { rewriteHistoryImages: core.rewriteHistoryImages },
   )
+  const sessionVisionPolicyStore = createSessionVisionPolicyRuntimeStore(legacyCoreCompat.ctx)
+  legacyCoreCompat.ctx.inject?.(['agents'], (agentsCtx) => {
+    installSessionVisionDelegationBoundary(
+      agentsCtx,
+      sessionVisionPolicyStore,
+      (parent) => resolveSessionVisionModeAuthority(
+        agentsCtx,
+        parent,
+        legacyCoreCompat.config,
+        { sessionPolicy: sessionVisionPolicyStore.get(String(parent.id)) },
+      ),
+    )
+  })
   const sessionVisionModeCompat = installSessionVisionModeBoundary(
     legacyCoreCompat.ctx,
     legacyCoreCompat.config,
+    { sessionVisionPolicyStore },
   )
 
+  return {
+    coreVisionSurfaceRuntime,
+    nativeImageCompat,
+    sessionVisionModeCompat,
+    sessionVisionPolicyStore,
+    sessionVisionRuntime,
+  }
+}
+
+function installRoutingAndHostProducts(host, owners, core) {
+  const { capabilityStore, logging, runtimeConfig, runtimePerformanceStore } = host
+  const { sessionVisionModeCompat } = owners
   // Final structured-flow guard sits closest to core.apply so it sees the
   // actual tool registrations and pre-step listener. The diagnostic observer
   // remains immediately inside it so existing timeout/budget semantics stay
@@ -266,6 +316,19 @@ export function applyVisionRuntimeComposition(ctx, config = {}, core) {
   })
   installPiAiBridgeWireCompat(reconciledCtx, logging.logger)
 
+  return {
+    breakerShadowHealth,
+    liveDiscovery,
+    reconciledCtx,
+    sessionEventTailReader,
+    sessionTurnResolver,
+  }
+}
+
+function installExecutionBoundaries(host, owners, routing, core, providerTransport) {
+  const { capabilityStore, logging, runtimeConfig, runtimeI18nCoreScope, runtimePerformanceStore } = host
+  const { sessionVisionRuntime } = owners
+  const { breakerShadowHealth, liveDiscovery, reconciledCtx } = routing
   const executionCtx = contextWithVisionExecutionPolicy(reconciledCtx, {
     isBridgeEvidence: (provider, model) => liveDiscovery.hasModel(provider, model),
     evidenceSource: (provider, model) => liveDiscovery.evidenceSource?.(provider, model),
@@ -314,11 +377,13 @@ export function applyVisionRuntimeComposition(ctx, config = {}, core) {
     core,
     evidenceSource: (provider, model) => liveDiscovery.evidenceSource?.(provider, model),
     logger: logging.logger,
+    providerTransport,
     finalContextDecorator: runtimeI18nCoreScope.decorate,
   })
   const capabilityBenchmark = installCapabilityBenchmarkService(backendRuntimeCtx, runtimeConfig, core, {
     logger: logging.logger,
     store: capabilityStore,
+    providerTransport,
   })
   attachCapabilityBenchmarkPresentation(capabilityBenchmark, {
     ctx: backendRuntimeCtx,
@@ -331,13 +396,28 @@ export function applyVisionRuntimeComposition(ctx, config = {}, core) {
   // Core owns exactly one agent/request routing hook. Protect the completed
   // provider/model handoff at that event boundary so future route-switch logic
   // cannot accidentally carry source-model call defaults into the target.
-  configureAgentRequestRouteAuthority(backendRuntimeCtx, {
+  const coreRequestAuthorityCtx = contextWithAgentRequestRouteAuthority(backendRuntimeCtx, {
     wrapperRoute: runtimeConfig.wrapperRoute,
     chainRoute: runtimeConfig.chainRoute,
     logger: logging.logger,
   })
-  const coreRequestAuthorityCtx = contextWithAgentRequestRouteAuthority(backendRuntimeCtx)
 
+  return { coreRequestAuthorityCtx }
+}
+
+function applyMatureCoreBridge(host, owners, routing, execution, core, runtime) {
+  const {
+    attachmentCompatCtx,
+    batchAttachmentHost,
+    hardenedConfig,
+    hostOwnsOfficialDeepSeek,
+    logging,
+    runtimeConfig,
+    runtimeI18nCoreScope,
+  } = host
+  const { coreVisionSurfaceRuntime, sessionVisionModeCompat, sessionVisionRuntime } = owners
+  const { breakerShadowHealth, sessionEventTailReader, sessionTurnResolver } = routing
+  const { coreRequestAuthorityCtx } = execution
   try {
     const c = hardenedConfig && typeof hardenedConfig === 'object' ? hardenedConfig : {}
     const local = c.localOllama && typeof c.localOllama === 'object' ? c.localOllama : {}
@@ -354,8 +434,27 @@ export function applyVisionRuntimeComposition(ctx, config = {}, core) {
     /* diagnostics must never break apply */
   }
 
-  try {
-    const result = runtimeI18nCoreScope.run(() =>
+  let schemaBootstrapFinished = false
+  const finishSchemaBootstrapOnce = () => {
+    if (schemaBootstrapFinished) return
+    schemaBootstrapFinished = true
+    coreVisionSurfaceRuntime.finishSchemaBootstrap()
+  }
+  const installPostCoreRuntime = () => {
+    installVisionMaintenanceRoutes(coreRequestAuthorityCtx, { logger: logging.logger })
+    finishSchemaBootstrapOnce()
+    installWrapperDirectoryAlias(attachmentCompatCtx, runtimeConfig, logging.logger)
+  }
+  const failCoreApply = (error) => {
+    finishSchemaBootstrapOnce()
+    logging.logger.error(
+      'vision-router: plugin apply failed: %s',
+      error && error.stack ? error.stack : error && error.message ? error.message : String(error),
+    )
+  }
+
+  return runCoreApplyLifecycle(
+    () => runtimeI18nCoreScope.run(() =>
       withVisionCircuitBreakerObserver(
         breakerShadowHealth.capture,
         () => core.apply(
@@ -367,28 +466,22 @@ export function applyVisionRuntimeComposition(ctx, config = {}, core) {
             sessionTurnResolver,
             sessionEventTailReader,
             hostOwnsOfficialDeepSeek,
+            providerTransport: runtime?.providerTransport,
           },
         ),
       ),
-    )
-    coreVisionSurfaceRuntime.finishSchemaBootstrap()
-    installWrapperDirectoryAlias(attachmentCompatCtx, runtimeConfig, logging.logger)
-    if (result && typeof result.then === 'function') {
-      return result.catch((error) => {
-        logging.logger.error(
-          'vision-router: plugin apply failed: %s',
-          error && error.stack ? error.stack : error && error.message ? error.message : String(error),
-        )
-        throw error
-      })
-    }
-    return result
-  } catch (error) {
-    coreVisionSurfaceRuntime.finishSchemaBootstrap()
-    logging.logger.error(
-      'vision-router: plugin apply failed: %s',
-      error && error.stack ? error.stack : error && error.message ? error.message : String(error),
-    )
-    throw error
-  }
-}
+    ),
+    {
+      onSuccess: installPostCoreRuntime,
+      onFailure: failCoreApply,
+    },
+  )
+}
+
+export function applyVisionRuntimeComposition(ctx, config = {}, core, runtime = {}) {
+  const host = installHostAndSecurityBoundaries(ctx, config, core)
+  const owners = createRuntimeOwners(host, core)
+  const routing = installRoutingAndHostProducts(host, owners, core)
+  const execution = installExecutionBoundaries(host, owners, routing, core, runtime?.providerTransport)
+  return applyMatureCoreBridge(host, owners, routing, execution, core, runtime)
+}

package/lib/runtime-i18n-boundary.js

@@ -1,6 +1,8 @@
 import { createRuntimeI18n, DEEP_TOOL_MOUNT_STATE } from './runtime-i18n.js'
 import { depthCopyFor } from './depth-guidance.js'
 import { blocksHaveRetainedImage } from './image-offload-compat.js'
+import { captureFetchDelegate, installFetchWrapper } from './fetch-wrapper-lifecycle.js'
+import { visionRouterMessageSource } from './session-message-source-compat.js'
 
 const PLUGIN_NAME = 'dsh-vision-router'
 const DEEP_TOOL_NAMES = new Set([
@@ -432,7 +434,7 @@ function addAutoMountReminder(decision, payload, i18n) {
         : `${Date.now()}-${Math.floor(Math.random() * 1e9)}`
     }`,
     content: [{ type: 'text', text: i18n.t('autoMountReminder') }],
-    source: { kind: 'plugin', plugin: PLUGIN_NAME },
+    source: visionRouterMessageSource(payload?.agent?.session),
   }
   const structuredIndex = base.findIndex((message) =>
     typeof message?.id === 'string' && message.id.startsWith('vision-router-structured-'),
@@ -520,9 +522,9 @@ function localizeRequestBody(value, i18n) {
 function installPromptFetchBoundary(ctx, i18n) {
   if (typeof ctx?.effect !== 'function' || typeof globalThis.fetch !== 'function') return
   ctx.effect(() => {
-    const originalFetch = globalThis.fetch
+    const delegateFetch = captureFetchDelegate()
     const localizedFetch = (input, init) => {
-      if (i18n.language() !== 'en' || typeof init?.body !== 'string') return originalFetch(input, init)
+      if (i18n.language() !== 'en' || typeof init?.body !== 'string') return delegateFetch(input, init)
       const body = init.body
       if (
         !body.includes('请按以下结构识别这张图片') &&
@@ -530,21 +532,18 @@ function installPromptFetchBoundary(ctx, i18n) {
         !body.includes(OCR_FALLBACK_PROMPT_ZH) &&
         !body.includes(LONG_SCREENSHOT_OCR_PROMPT_ZH)
       ) {
-        return originalFetch(input, init)
+        return delegateFetch(input, init)
       }
       try {
         const parsed = JSON.parse(body)
         const localized = localizeRequestBody(parsed, i18n)
-        if (localized === parsed) return originalFetch(input, init)
-        return originalFetch(input, { ...init, body: JSON.stringify(localized) })
+        if (localized === parsed) return delegateFetch(input, init)
+        return delegateFetch(input, { ...init, body: JSON.stringify(localized) })
       } catch {
-        return originalFetch(input, init)
+        return delegateFetch(input, init)
       }
     }
-    globalThis.fetch = localizedFetch
-    return () => {
-      if (globalThis.fetch === localizedFetch) globalThis.fetch = originalFetch
-    }
+    return installFetchWrapper(localizedFetch)
   }, 'vision-router: runtime i18n prompt boundary')
 }
 

package/lib/screenshot-source-boundary.js

@@ -110,7 +110,7 @@ function wrapTools(tools, ctx, core) {
 export function installScreenshotSourceBoundary(ctx, core) {
   if (!ctx || (typeof ctx !== 'object' && typeof ctx !== 'function')) return ctx
   const cached = wrappedContexts.get(ctx)
-  if (cached) return cached
+  if (cached?.core === core) return cached.wrapped
   let wrapped
   wrapped = new Proxy(ctx, {
     get(target, property) {
@@ -119,6 +119,6 @@ export function installScreenshotSourceBoundary(ctx, core) {
       return typeof value === 'function' ? value.bind(target) : value
     },
   })
-  wrappedContexts.set(ctx, wrapped)
+  wrappedContexts.set(ctx, { core, wrapped })
   return wrapped
 }

package/lib/session-affinity-runtime.js

@@ -1,104 +1,120 @@
-import { AsyncLocalStorage } from 'node:async_hooks'
-import { rawSessionIdentity } from './session-affinity.js'
-
-const affinityRuntime = new AsyncLocalStorage()
-
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { rawSessionIdentity } from './session-affinity.js';
+const affinityRuntime = new AsyncLocalStorage();
+function propertyBag(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function')
+        ? value
+        : undefined;
+}
+function isPromiseLike(value) {
+    return typeof propertyBag(value)?.then === 'function';
+}
 export function currentVisionSessionAffinityId() {
-  const state = affinityRuntime.getStore()
-  return state?.active === true ? state.affinityId : undefined
+    const state = affinityRuntime.getStore();
+    return state?.active === true ? state.affinityId : undefined;
 }
-
 export function runWithVisionSessionAffinity(affinityId, callback) {
-  const raw = rawSessionIdentity(affinityId)
-  if (raw === undefined) return callback()
-  const state = { affinityId: raw, active: true }
-  let result
-  try {
-    result = affinityRuntime.run(state, callback)
-  } catch (error) {
-    state.active = false
-    throw error
-  }
-  if (result && typeof result.then === 'function') {
-    return Promise.resolve(result).finally(() => { state.active = false })
-  }
-  state.active = false
-  return result
+    const raw = rawSessionIdentity(affinityId);
+    if (raw === undefined)
+        return callback();
+    const state = {
+        affinityId: raw,
+        active: true,
+    };
+    let result;
+    try {
+        result = affinityRuntime.run(state, callback);
+    }
+    catch (error) {
+        state.active = false;
+        throw error;
+    }
+    if (isPromiseLike(result)) {
+        return Promise.resolve(result).finally(() => {
+            state.active = false;
+        });
+    }
+    state.active = false;
+    return result;
 }
-
-/**
- * Keep AsyncLocalStorage active across lazy AsyncIterable creation and every
- * iterator operation. Adapter/network work often begins on next(), not when
- * ctx.llm.stream() returns the iterable. Promise-returning test/compat streams
- * are supported too because some older seams resolve the iterable lazily.
- * One mutable state object is retired at stream completion so async work that
- * outlives the model request cannot keep projecting the conversation id.
- */
 export function streamWithVisionSessionAffinity(affinityId, streamFactory) {
-  const raw = rawSessionIdentity(affinityId)
-  if (raw === undefined) return streamFactory()
-  return {
-    [Symbol.asyncIterator]() {
-      const state = { affinityId: raw, active: true }
-      let iteratorPromise
-      const retire = () => { state.active = false }
-      const ensure = () => {
-        if (iteratorPromise === undefined) {
-          iteratorPromise = affinityRuntime.run(state, async () => {
-            const stream = await streamFactory()
-            if (!stream || typeof stream[Symbol.asyncIterator] !== 'function') {
-              throw new TypeError('scoped vision stream is not async iterable')
-            }
-            return stream[Symbol.asyncIterator]()
-          })
-        }
-        return iteratorPromise
-      }
-      return {
-        next(value) {
-          return affinityRuntime.run(state, async () => {
-            try {
-              const result = await (await ensure()).next(value)
-              if (result?.done === true) retire()
-              return result
-            } catch (error) {
-              retire()
-              throw error
-            }
-          })
-        },
-        return(value) {
-          if (iteratorPromise === undefined) {
-            retire()
-            return Promise.resolve({ done: true, value })
-          }
-          return affinityRuntime.run(state, async () => {
-            try {
-              const active = await iteratorPromise
-              return typeof active.return === 'function'
-                ? await active.return(value)
-                : { done: true, value }
-            } finally {
-              retire()
-            }
-          })
-        },
-        throw(error) {
-          if (iteratorPromise === undefined) {
-            retire()
-            return Promise.reject(error)
-          }
-          return affinityRuntime.run(state, async () => {
-            try {
-              const active = await iteratorPromise
-              if (typeof active.throw === 'function') return await active.throw(error)
-              throw error
-            } finally {
-              retire()
-            }
-          })
+    const raw = rawSessionIdentity(affinityId);
+    if (raw === undefined)
+        return streamFactory();
+    return {
+        [Symbol.asyncIterator]() {
+            const state = {
+                affinityId: raw,
+                active: true,
+            };
+            let iteratorPromise;
+            const retire = () => {
+                state.active = false;
+            };
+            const ensure = () => {
+                if (iteratorPromise === undefined) {
+                    iteratorPromise = affinityRuntime.run(state, async () => {
+                        const stream = await streamFactory();
+                        if (stream === null
+                            || (typeof stream !== 'object' && typeof stream !== 'function')
+                            || typeof stream[Symbol.asyncIterator] !== 'function') {
+                            throw new TypeError('scoped vision stream is not async iterable');
+                        }
+                        return stream[Symbol.asyncIterator]();
+                    });
+                }
+                return iteratorPromise;
+            };
+            return {
+                next(value) {
+                    return affinityRuntime.run(state, async () => {
+                        try {
+                            const result = await (await ensure()).next(value);
+                            if (result?.done === true)
+                                retire();
+                            return result;
+                        }
+                        catch (error) {
+                            retire();
+                            throw error;
+                        }
+                    });
+                },
+                return(value) {
+                    if (iteratorPromise === undefined) {
+                        retire();
+                        return Promise.resolve({ done: true, value });
+                    }
+                    return affinityRuntime.run(state, async () => {
+                        try {
+                            const active = await ensure();
+                            return typeof active.return === 'function'
+                                ? await active.return(value)
+                                : { done: true, value };
+                        }
+                        finally {
+                            retire();
+                        }
+                    });
+                },
+                throw(error) {
+                    if (iteratorPromise === undefined) {
+                        retire();
+                        return Promise.reject(error);
+                    }
+                    return affinityRuntime.run(state, async () => {
+                        try {
+                            const active = await ensure();
+                            if (typeof active.throw === 'function')
+                                return await active.throw(error);
+                            throw error;
+                        }
+                        finally {
+                            retire();
+                        }
+                    });
+                },
+            };
         },
-      }
-    },
-  }
+    };
 }