dsh-vision-router 2.1.6 → 2.2.0

package/lib/core-primitives.js

@@ -72,6 +72,7 @@ import {
 } from './http-body-limit.js'
 import { writeArtifactFile } from './artifact-boundary.js'
 import { stripTrailingSlashes } from './string-normalization.js'
+import { isOffloadedImageBlock, offloadedImagePlaceholder } from './image-offload-compat.js'
 import { proxyHostMatchesAny } from './proxy-routing.js'
 import { parseVersionComparator } from './version-range.js'
 import { captureWindowsDesktop } from './windows-desktop-capture.js'
@@ -1454,6 +1455,108 @@ export async function ocrWithTesseract(bytes, timeoutMs = 60000) {
   return String(stdout ?? '')
 }
 
+const TESSERACT_OCR_PSMS = Object.freeze([6, 3, 11])
+const TESSERACT_REVIEW_THRESHOLD = 70
+const TESSERACT_CANDIDATE_MARGIN = 5
+const TESSERACT_CONFUSABLE_RUN = /[0O1IlL]{3,}/
+
+function median(values) {
+  if (!Array.isArray(values) || values.length === 0) return 0
+  const ordered = [...values].sort((a, b) => a - b)
+  const middle = Math.floor(ordered.length / 2)
+  return ordered.length % 2 === 0
+    ? (ordered[middle - 1] + ordered[middle]) / 2
+    : ordered[middle]
+}
+
+export function parseTesseractTsv(tsv) {
+  const words = []
+  for (const line of String(tsv ?? '').split(/\r?\n/).slice(1)) {
+    const columns = line.split('\t')
+    if (columns.length < 12) continue
+    const confidence = Number(columns[10])
+    const text = columns.slice(11).join('\t').trim()
+    if (text === '' || !Number.isFinite(confidence) || confidence < 0) continue
+    words.push({ text, confidence })
+  }
+  return words
+}
+
+export function assessTesseractOcr(text, tsv, psm = 6) {
+  const words = parseTesseractTsv(tsv)
+  const confidences = words.map((word) => word.confidence)
+  const precisionWords = words.filter((word) => /[0-9$%#:/._-]/.test(word.text))
+  const precisionConfidences = precisionWords.map((word) => word.confidence)
+  const riskyTokens = words
+    .map((word) => word.text)
+    .filter((token) => TESSERACT_CONFUSABLE_RUN.test(token))
+  const quality = precisionConfidences.length > 0
+    ? Math.min(...precisionConfidences)
+    : median(confidences)
+  return {
+    psm,
+    text: String(text ?? '').trim(),
+    words: words.length,
+    quality: Number.isFinite(quality) ? quality : 0,
+    riskyTokens,
+    uncertain: words.length === 0 || quality < TESSERACT_REVIEW_THRESHOLD || riskyTokens.length > 0,
+  }
+}
+
+export function selectTesseractOcrCandidate(candidates) {
+  const usable = (Array.isArray(candidates) ? candidates : []).filter((candidate) => candidate && candidate.text)
+  if (usable.length === 0) return undefined
+  let selected = usable[0]
+  for (const candidate of usable.slice(1)) {
+    if (candidate.quality >= selected.quality + TESSERACT_CANDIDATE_MARGIN) selected = candidate
+  }
+  return selected
+}
+
+export async function ocrWithTesseractAdaptive(bytes, timeoutMs = 12000, options = {}) {
+  const exec = typeof options.exec === 'function' ? options.exec : promisify(execFile)
+  const requestedBudget = Number(timeoutMs)
+  const budgetMs = Number.isFinite(requestedBudget) && requestedBudget > 0
+    ? Math.min(60000, requestedBudget)
+    : 12000
+  const started = Date.now()
+  const attemptedPsms = []
+  const remaining = () => Math.max(1, budgetMs - (Date.now() - started))
+  const run = async (psm) => {
+    attemptedPsms.push(psm)
+    const common = ['stdin', 'stdout', '-l', 'chi_sim+eng', '--psm', String(psm)]
+    const execOptions = () => ({
+      timeout: remaining(),
+      maxBuffer: 32 * 1024 * 1024,
+      input: bytes,
+    })
+    const { stdout: plain } = await exec('tesseract', common, execOptions())
+    const text = String(plain ?? '').trim()
+    if (text === '') return assessTesseractOcr('', '', psm)
+    try {
+      const { stdout: tsv } = await exec('tesseract', [...common, 'tsv'], execOptions())
+      return assessTesseractOcr(text, String(tsv ?? ''), psm)
+    } catch {
+      return { psm, text, words: 0, quality: 0, riskyTokens: [], uncertain: true }
+    }
+  }
+
+  const candidates = [await run(TESSERACT_OCR_PSMS[0])]
+  if (candidates[0].text !== '' && !candidates[0].uncertain) {
+    return { ...candidates[0], attemptedPsms }
+  }
+  for (const psm of TESSERACT_OCR_PSMS.slice(1)) {
+    if (Date.now() - started >= budgetMs) break
+    try {
+      candidates.push(await run(psm))
+    } catch {
+      // Keep the first successful local OCR result when an optional review pass fails.
+    }
+  }
+  const selected = selectTesseractOcrCandidate(candidates) ?? candidates[0]
+  return { ...selected, attemptedPsms }
+}
+
 /** Rough token estimate for one message (no tokenizer; conservative on purpose). */
 export function estimateTokens(message) {
   let chars = 0
@@ -1467,7 +1570,10 @@ export function estimateTokens(message) {
     if (typeof block.text === 'string') chars += block.text.length
     if (typeof block.arguments === 'string') chars += block.arguments.length
     if (typeof block.name === 'string') chars += block.name.length
-    if (block.type === 'image') images += 1
+    if (block.type === 'image') {
+      if (isOffloadedImageBlock(block)) chars += offloadedImagePlaceholder(block).length
+      else images += 1
+    }
     if (Array.isArray(block.content)) block.content.forEach(walk)
   }
   if (message === null || message === undefined) return 0
@@ -1949,6 +2055,9 @@ export function dedupeHttpProviders(pairs, httpProviders) {
 /** Convert harness image/text blocks plus resolved image bytes into OpenAI wire content. */
 export function toOpenAIContent(blocks, bytesOf) {
   return blocks.map((block) => {
+    if (isOffloadedImageBlock(block)) {
+      return { type: 'text', text: offloadedImagePlaceholder(block) }
+    }
     if (block && block.type === 'image' && block.attachment) {
       const bytes = bytesOf(block.attachment)
       const data = Buffer.from(bytes).toString('base64')
@@ -2162,9 +2271,10 @@ export function launchEnvironmentLike(env) {
 }
 
 /**
- * Rebuild the stock DeepSeek adapter from this plugin for the stealth
- * takeover: the `llm-deepseek` settings section + the credential seam + the
- * anonymous user id, exactly like the stock row does it.
+ * Legacy-only DeepSeek reconstruction for Host contracts that do not own the
+ * official provider lifecycle. Modern Hosts keep `deepseek-official` Host-owned
+ * because request-local attachment/file/image-access seams cannot be cloned
+ * safely here. Remove this helper when the legacy takeover window is retired.
  */
 export function createNativeDeepSeekAdapter(ctx) {
   const env = launchEnvironmentLike(
@@ -2262,7 +2372,7 @@ export async function buildInstantLocalMap(ctx, messages, provider, options = {}
   for (const message of messages) {
     if (!message || !Array.isArray(message.content)) continue
     for (const block of message.content) {
-      if (!block || block.type !== 'image' || !block.attachment) continue
+      if (!block || block.type !== 'image' || !block.attachment || isOffloadedImageBlock(block)) continue
       const attachment = block.attachment
       const id = attachment.attachmentId || attachment.id || ''
       if (id === '' || seen.has(id)) continue
@@ -2502,11 +2612,16 @@ export function createWrapperStreamBody(ctx, { imageMemory, delegateProvider, pr
         })
         return result.changed ? { ...message, content: result.content } : message
       })
+      // Provider authority can be live (for example the main DeepSeek wrapper
+      // switches to its hidden native route only after a delayed takeover).
+      // Resolve it once per model call so metadata, reasoning memory and the
+      // actual network dispatch all use one coherent delegate identity.
+      const currentDelegateProvider = liveValue(delegateProvider)
       // Remember per delegate+model rather than per delegate alone: the
       // stream boundary carries no session id, so provider+model is the
       // narrowest scope available and keeps two concurrent sessions on the
       // same twin from sharing one memory slot.
-      const effortKey = `${delegateProvider}\u0000${options.model ?? ''}`
+      const effortKey = `${currentDelegateProvider}\u0000${options.model ?? ''}`
       let effort = typeof options.reasoningEffort === 'string' && options.reasoningEffort !== ''
         ? options.reasoningEffort
         : undefined
@@ -2517,7 +2632,7 @@ export function createWrapperStreamBody(ctx, { imageMemory, delegateProvider, pr
       }
       yield* ctx.llm.stream({
         ...(effort === undefined ? options : { ...options, reasoningEffort: effort }),
-        provider: delegateProvider,
+        provider: currentDelegateProvider,
         messages: rewritten,
       })
     },

package/lib/degraded-local-evidence.js

@@ -0,0 +1,39 @@
+/** Bounded policy for stopping Host tools from re-parsing images after vision degradation. */
+
+function flattenStrings(value, out = [], depth = 0) {
+  if (out.length >= 64 || depth > 6 || value == null) return out
+  if (typeof value === 'string') { out.push(value); return out }
+  if (Array.isArray(value)) {
+    for (const item of value) flattenStrings(item, out, depth + 1)
+    return out
+  }
+  if (typeof value === 'object') {
+    for (const item of Object.values(value)) flattenStrings(item, out, depth + 1)
+  }
+  return out
+}
+
+function normalizedEvidenceTokens(tokens) {
+  const out = []
+  for (const token of tokens) {
+    if (typeof token !== 'string' || token === '') continue
+    out.push(token)
+    if (token.startsWith('sha256:')) {
+      const digest = token.slice('sha256:'.length)
+      out.push(digest)
+      if (digest.length >= 16) out.push(digest.slice(0, 16))
+    }
+  }
+  return out
+}
+
+export function shouldBlockDegradedHostTool(name, args, evidenceTokens = []) {
+  if (name !== 'bash' && name !== 'read_image') return false
+  const tokens = normalizedEvidenceTokens(evidenceTokens)
+  if (tokens.length === 0) return false
+  const strings = flattenStrings(args)
+  return strings.some((text) => {
+    if (text.includes('.dsh/attachments') || text.includes('/attachments/v1/objects/')) return true
+    return tokens.some(token => text.includes(token))
+  })
+}

package/lib/dsh-contract-compat.js

@@ -26,6 +26,197 @@ const VISION_ROUTER_NORMALIZED_BYTES = LEGACY_VISION_ATTACHMENT_BYTES
 const HOST_CAPABILITIES_PATH = '/_dsh/vision-router/host-capabilities'
 const capabilityRouteInstalls = new WeakSet()
 
+function sessionQueryOf(ctx) {
+  if (!ctx || typeof ctx !== 'object') return undefined
+  try {
+    if (typeof ctx.get === 'function') {
+      const query = ctx.get('sessionQuery')
+      if (query && typeof query === 'object') return query
+    }
+  } catch {
+    // A partial/legacy Host may not expose SessionQuery through ctx.get().
+  }
+  try {
+    const query = ctx.sessionQuery
+    return query && typeof query === 'object' ? query : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Build the narrow bounded Session event reader used by durable surface repair.
+ * DSH rc.8+ exposes `sessionQuery.readEvent({ sessionId, seq })`; resolve the
+ * service at call time so Host service replacement/hot reload stays visible.
+ * Missing capability is explicit and lets isolated/legacy callers use their
+ * existing Session-local compatibility fallback. Once the Host advertises the
+ * reader, operational failures propagate instead of silently falling back to
+ * deprecated synchronous Session history.
+ */
+export function createSessionEventReader(ctx) {
+  return async function readSessionEvent(session, seq) {
+    const sessionId = session?.id
+    if (sessionId === undefined || sessionId === null) return { supported: false }
+    if (!Number.isSafeInteger(seq) || seq < 0 || Object.is(seq, -0)) {
+      throw new TypeError(`session event seq must be a non-negative safe integer, got ${String(seq)}`)
+    }
+    const query = sessionQueryOf(ctx)
+    if (!query || typeof query.readEvent !== 'function') return { supported: false }
+    const window = await query.readEvent({ sessionId, seq })
+    const event = window?.target
+    if (!event || typeof event !== 'object') {
+      throw new Error(`sessionQuery.readEvent returned no target for seq ${seq}`)
+    }
+    if (event.seq !== undefined && event.seq !== seq) {
+      throw new Error(`sessionQuery.readEvent returned seq ${String(event.seq)} for requested seq ${seq}`)
+    }
+    return { supported: true, event }
+  }
+}
+
+
+const SESSION_EVENT_TAIL_INITIAL_AFTER = 50
+const SESSION_EVENT_TAIL_MAX_EVENTS = 4096
+const SESSION_EVENT_TAIL_MAX_READS = 128
+
+function sessionQueryCode(error) {
+  return typeof error?.code === 'string' ? error.code : undefined
+}
+
+/**
+ * Read raw Session events strictly after one known committed seq through the
+ * Host-owned bounded `sessionQuery.readEvent()` window contract.
+ *
+ * The reader adapts to deployments that lower SessionQuery's configurable
+ * `readWindowMax`, never materializes the full Session log, and caps both
+ * events and Host reads. Missing capability is explicit. Operational failures
+ * from an advertised capability propagate to the caller; a cap is reported as
+ * `truncated` so routing can fail safe without a synchronous-history fallback.
+ */
+export function createSessionEventTailReader(ctx) {
+  let afterHint = SESSION_EVENT_TAIL_INITIAL_AFTER
+
+  const readWindow = async (query, sessionId, seq) => {
+    let after = afterHint
+    while (true) {
+      try {
+        const request = after > 0 ? { sessionId, seq, after } : { sessionId, seq }
+        const window = await query.readEvent(request)
+        afterHint = after
+        return { window, after }
+      } catch (error) {
+        if (sessionQueryCode(error) !== 'SESSION_QUERY_INVALID_WINDOW' || after <= 0) throw error
+        after = after <= 1 ? 0 : Math.floor(after / 2)
+      }
+    }
+  }
+
+  return async function readSessionEventTail(session, anchorSeq, options = {}) {
+    const sessionId = session?.id
+    if (sessionId === undefined || sessionId === null) return { supported: false }
+    if (!Number.isSafeInteger(anchorSeq) || anchorSeq < 0 || Object.is(anchorSeq, -0)) {
+      throw new TypeError(`session tail anchor seq must be a non-negative safe integer, got ${String(anchorSeq)}`)
+    }
+    const query = sessionQueryOf(ctx)
+    if (!query || typeof query.readEvent !== 'function') return { supported: false }
+
+    const collect = options?.collect !== false
+    const events = []
+    let capturedThroughSeq = anchorSeq
+    let cursor = anchorSeq
+    let inspected = 0
+    let reads = 0
+
+    while (reads < SESSION_EVENT_TAIL_MAX_READS) {
+      let result
+      try {
+        result = await readWindow(query, sessionId, cursor)
+      } catch (error) {
+        if (sessionQueryCode(error) === 'SESSION_QUERY_EVENT_NOT_FOUND' && cursor > anchorSeq) {
+          return { supported: true, events, capturedThroughSeq, truncated: false }
+        }
+        throw error
+      }
+      reads += 1
+
+      const window = result.window
+      const target = window?.target
+      if (!target || typeof target !== 'object' || target.seq !== cursor) {
+        throw new Error(`sessionQuery.readEvent returned an invalid target for seq ${cursor}`)
+      }
+      if (!Array.isArray(window.events) || window.events.length === 0) {
+        throw new Error(`sessionQuery.readEvent returned no event window for seq ${cursor}`)
+      }
+      const windowEvents = window.events
+      let expectedSeq = cursor
+      let endSeq = cursor
+      for (const event of windowEvents) {
+        const seq = event?.seq
+        if (!Number.isSafeInteger(seq) || seq !== expectedSeq) {
+          throw new Error(
+            `sessionQuery.readEvent returned non-contiguous seq ${String(seq)}; expected ${expectedSeq}`,
+          )
+        }
+        expectedSeq += 1
+        endSeq = seq
+        if (seq <= capturedThroughSeq) continue
+        capturedThroughSeq = seq
+        inspected += 1
+        if (collect) events.push(event)
+        if (inspected >= SESSION_EVENT_TAIL_MAX_EVENTS) {
+          return { supported: true, events, capturedThroughSeq, truncated: true }
+        }
+      }
+      if (Number.isSafeInteger(window?.endSeq) && window.endSeq !== endSeq) {
+        throw new Error(
+          `sessionQuery.readEvent returned endSeq ${String(window.endSeq)} for window ending at ${endSeq}`,
+        )
+      }
+
+      if (result.after > 0) {
+        if (endSeq <= cursor || windowEvents.length < result.after + 1) {
+          return { supported: true, events, capturedThroughSeq: Math.max(capturedThroughSeq, endSeq), truncated: false }
+        }
+        cursor = endSeq
+        continue
+      }
+
+      // `readWindowMax: 0` is a valid Host configuration. Walk exact seqs and
+      // use the typed EVENT_NOT_FOUND result as the logical tail sentinel.
+      cursor += 1
+    }
+
+    return { supported: true, events, capturedThroughSeq, truncated: true }
+  }
+}
+
+
+/**
+ * Build the narrow asynchronous Session-log reader used only for cold
+ * canonical attachment recovery after the bounded cache evicts a ref.
+ * Supported Hosts own replay validation through `sessionQuery.readSession()`;
+ * callers receive detached events and never touch synchronous Session history.
+ */
+export function createSessionLogReader(ctx) {
+  return async function readSessionLog(session) {
+    const sessionId = session?.id
+    if (sessionId === undefined || sessionId === null) return { supported: false }
+    const query = sessionQueryOf(ctx)
+    if (!query || typeof query.readSession !== 'function') return { supported: false }
+    const snapshot = await query.readSession(sessionId)
+    if (!snapshot || !Array.isArray(snapshot.events)) {
+      throw new Error('sessionQuery.readSession returned no event log')
+    }
+    const observedId = snapshot.session?.id
+    if (observedId !== undefined && observedId !== sessionId) {
+      throw new Error(
+        `sessionQuery.readSession returned session ${String(observedId)} for requested ${String(sessionId)}`,
+      )
+    }
+    return { supported: true, events: snapshot.events }
+  }
+}
+
 function attachmentStoreOf(ctx) {
   if (!ctx || typeof ctx !== 'object') return undefined
   try {
@@ -111,6 +302,17 @@ export function hasBatchAttachmentContract(ctx) {
   return !!store && typeof store.saveImages === 'function'
 }
 
+/**
+ * DSH Hosts on the canonical batch-attachment contract also keep the official
+ * DeepSeek provider Host-owned. Later generations add still more request-local
+ * file/image-access seams, so DVR may wrap this provider but must never rebuild
+ * or resurrect it. Keep this semantic fact
+ * centralized so Core does not grow a second Host-generation detector.
+ */
+export function hostOwnsOfficialDeepSeekProvider(ctx) {
+  return hasBatchAttachmentContract(ctx)
+}
+
 function exactAlphaNormalizationDefaults(policy) {
   return !!policy && typeof policy === 'object' &&
     policy.maxPixels === DSH_ALPHA_DEFAULT_NORMALIZED_PIXELS &&

package/lib/dsh-support-window.js

@@ -6,7 +6,7 @@ export const DSH_SUPPORT_WINDOW = Object.freeze({
 
 export const DSH_VERIFICATION_EVIDENCE = Object.freeze({
   exactStable: '0.1.5-rc.2',
-  exactPreview: '0.1.5-alpha.2',
+  exactPreview: '0.1.6-alpha.1',
   stableCanaryDistTag: 'latest',
   previewCanaryDistTag: 'alpha',
 })

package/lib/image-offload-compat.js

@@ -0,0 +1,38 @@
+function boundedAttachmentId(block) {
+  const attachment = block && typeof block === 'object' ? block.attachment : undefined
+  const raw = attachment && (attachment.attachmentId ?? attachment.id)
+  if (typeof raw !== 'string' || raw.trim() === '') return undefined
+  return raw.trim().slice(0, 256)
+}
+
+/** DSH 0.1.6+ marks durable request-limit omissions on the ImageBlock itself. */
+export function isOffloadedImageBlock(block) {
+  return !!block && block.type === 'image' && block.offloaded === true
+}
+
+export function blocksHaveRetainedImage(content) {
+  if (!Array.isArray(content)) return false
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue
+    if (block.type === 'image' && block.offloaded !== true) return true
+    if (Array.isArray(block.content) && blocksHaveRetainedImage(block.content)) return true
+  }
+  return false
+}
+
+/**
+ * Dependency-free model-facing placeholder for an image DSH already offloaded.
+ *
+ * Do not import the 0.1.6 `offloadedImageText` helper here: DVR still supports
+ * older Hosts where that export does not exist. The durable attachment stays
+ * available to Vision Router tools, but custom wire serializers must never
+ * read or resend its bytes once the Host projection marks this occurrence.
+ */
+export function offloadedImagePlaceholder(block) {
+  const id = boundedAttachmentId(block)
+  if (id === undefined) {
+    return '[image omitted to fit request image limits; attachment id unavailable]'
+  }
+  return `[image omitted to fit request image limits; attachment ${id}. ` +
+    `To inspect it again, call vision_describe with attachmentIds: [${JSON.stringify(id)}].]`
+}