dsh-vision-router 2.1.7 → 2.2.0

package/lib/session-vision-index.js

@@ -1,11 +1,12 @@
 import { currentSessionSurfacePolicy } from './session-surface-policy.js'
+import { sessionSurfaceReplacementIntent } from './session-surface-compat.js'
 import { createSessionVisionStateStore } from './session-vision-state.js'
 
 function isObject(value) {
   return value !== null && typeof value === 'object'
 }
 
-function sessionEvents(session) {
+function legacySessionEvents(session) {
   try {
     // dsh 0.1.2-alpha.4 removed the bare `session.events` array in favor of
     // `session.snapshotEvents()`; both are handled so one build runs on both
@@ -42,19 +43,21 @@ function boundedMessage(error) {
  * Session visual data-plane index.
  *
  * SessionVisionStateStore remains the bounded storage owner. This object owns
- * incremental durable-log scan, target-only recovery after bounded-cache
- * eviction, tool-result image surface repair and expired structured guard-stop
- * surface repair.
+ * target-only durable attachment recovery after bounded-cache eviction,
+ * bounded Host-backed tool-result image surface repair and expired structured
+ * guard-stop surface repair.
  *
- * The index never replaces stateStore.lookupAttachment(). Durable recovery is
- * requested explicitly through index.lookupAttachment(), so storage and
- * recovery ownership remain visible at the call site.
+ * The index never replaces stateStore.lookupAttachment(). Cache lookup stays
+ * synchronous through lookupAttachment(); cold durable recovery is requested
+ * explicitly through async resolveAttachment(), so I/O ownership remains visible.
  */
 export function createSessionVisionIndex({
   stateStore,
   core,
   config = {},
   logger,
+  readSessionEvent,
+  readSessionLog,
 } = {}) {
   if (!core || typeof core !== 'object') throw new TypeError('session vision index requires core helpers')
 
@@ -70,59 +73,99 @@ export function createSessionVisionIndex({
     : undefined
   const toolSurfaceScans = new WeakMap()
   const guardSurfaceScans = new WeakMap()
+  const unsupportedSurfaceContracts = new WeakSet()
+  const repairReadWarnings = new WeakMap()
+  const attachmentRecoveryWarnings = new WeakMap()
 
   const recordAttachments = (session, refs) => {
     if (!session || !Array.isArray(refs) || refs.length === 0) return
     store.recordAttachments(session, refs)
   }
 
-  const scanEventLog = (session) => {
-    if (!session) return
-    const events = sessionEvents(session)
-    if (!events || events.length === 0) return
-    const last = store.getScannedEventSeq(session)
-    if (last >= events.length) return
-    const refs = typeof core.collectEventAttachmentRefs === 'function'
-      ? core.collectEventAttachmentRefs(events.slice(last))
-      : []
-    // Advance even when no refs are present so irrelevant durable history is
-    // never rescanned indefinitely.
-    store.setScannedEventSeq(session, events.length)
-    if (Array.isArray(refs) && refs.length > 0) store.recordAttachments(session, refs)
-  }
 
+  // Synchronous lookup is cache-only. Projected short handles first warm this
+  // cache from current derived messages and must not trigger historical I/O.
   const lookupAttachment = (session, id) => {
     if (!primitiveLookup) return undefined
-    let hit = primitiveLookup(session, id)
-    if (hit !== undefined) return hit
-    if (session === undefined) return undefined
-
-    scanEventLog(session)
-    hit = primitiveLookup(session, id)
-    if (hit !== undefined) return hit
+    return primitiveLookup(session, id)
+  }
 
-    // Bounded cache eviction is a performance event, never a correctness
-    // event. Recover only the requested durable ref instead of rebuilding an
-    // unbounded attachment index.
-    const events = sessionEvents(session)
-    if (!events || events.length === 0 || typeof core.collectEventAttachmentRefs !== 'function') {
-      return undefined
+  const recoverAttachmentsFromEvents = (session, ids, events) => {
+    const found = new Map()
+    if (!Array.isArray(events) || events.length === 0 || typeof core.collectEventAttachmentRefs !== 'function') {
+      return found
+    }
+    const wanted = new Set(ids.map((id) => String(id)))
+    for (const ref of core.collectEventAttachmentRefs(events)) {
+      if (!ref) continue
+      const id = String(ref.attachmentId ?? ref.id)
+      if (wanted.has(id) && !found.has(id)) found.set(id, ref)
     }
-    const wanted = String(id)
-    const recovered = core.collectEventAttachmentRefs(events).find(
-      (ref) => ref && String(ref.attachmentId ?? ref.id) === wanted,
+    if (found.size > 0) store.recordAttachments(session, [...found.values()])
+    return found
+  }
+
+  const warnAttachmentRecoveryFailure = (session, id, error) => {
+    const message = boundedMessage(error)
+    const key = `${String(id)}:${message}`
+    if (attachmentRecoveryWarnings.get(session) === key) return
+    attachmentRecoveryWarnings.set(session, key)
+    logger?.warn?.(
+      'vision-router: session attachment recovery failed id=%s error=%s',
+      String(id),
+      message,
     )
-    if (recovered !== undefined) {
-      store.recordAttachments(session, [recovered])
-      return recovered
+  }
+
+  const resolveAttachments = async (session, ids) => {
+    const requested = [...new Set((Array.isArray(ids) ? ids : []).map((id) => String(id)))]
+    const resolved = new Map()
+    const missing = []
+    for (const id of requested) {
+      const cached = lookupAttachment(session, id)
+      if (cached !== undefined) resolved.set(id, cached)
+      else missing.push(id)
     }
-    return undefined
+    if (missing.length === 0 || session === undefined) return resolved
+
+    let events
+    if (typeof readSessionLog === 'function') {
+      let result
+      try {
+        result = await readSessionLog(session)
+      } catch (error) {
+        warnAttachmentRecoveryFailure(session, missing[0], error)
+        return resolved
+      }
+      if (result?.supported === true) {
+        attachmentRecoveryWarnings.delete(session)
+        events = result.events
+      } else if (result?.supported !== false) {
+        warnAttachmentRecoveryFailure(
+          session,
+          missing[0],
+          new Error('Session log reader returned an invalid capability result'),
+        )
+        return resolved
+      }
+    }
+
+    // Historical/partial Hosts without SessionQuery keep the released fallback.
+    // Public rc8+ Hosts use readSessionLog above and never touch sync history.
+    if (events === undefined) events = legacySessionEvents(session)
+    const recovered = recoverAttachmentsFromEvents(session, missing, events)
+    for (const [id, ref] of recovered) resolved.set(id, ref)
+    return resolved
+  }
+
+  const resolveAttachment = async (session, id) => {
+    return (await resolveAttachments(session, [id])).get(String(id))
   }
 
-  const nextSurfaceSeqs = (scans, session) => {
-    if (!session) return []
+  const pendingSurfaceScan = (scans, session) => {
+    if (!session) return undefined
     const nodes = surfaceNodes(session)
-    if (!nodes || nodes.length === 0) return []
+    if (!nodes || nodes.length === 0) return undefined
     let scan = scans.get(session)
     if (!scan) {
       scan = { count: 0 }
@@ -131,9 +174,54 @@ export function createSessionVisionIndex({
     // Compaction/resume may shrink/rebuild the surface. Reset the incremental
     // cursor rather than assuming old indices still refer to the new surface.
     if (scan.count > nodes.length) scan.count = 0
-    const fresh = nodes.slice(scan.count)
-    scan.count = nodes.length
-    return fresh
+    const count = nodes.length
+    const seqs = nodes.slice(scan.count)
+    if (seqs.length === 0) return undefined
+    return {
+      seqs,
+      advance() {
+        if (scan.count < count) scan.count += 1
+      },
+    }
+  }
+
+  const warnRepairReadFailure = (session, seq, error) => {
+    const message = boundedMessage(error)
+    const previous = repairReadWarnings.get(session)
+    if (previous?.seq === seq && previous.message === message) return
+    repairReadWarnings.set(session, { seq, message })
+    logger?.warn?.(
+      'vision-router: session surface event read failed seq=%s error=%s',
+      seq,
+      message,
+    )
+  }
+
+  const eventForSurfaceRepair = async (session, seq) => {
+    if (typeof readSessionEvent === 'function') {
+      let result
+      try {
+        result = await readSessionEvent(session, seq)
+      } catch (error) {
+        warnRepairReadFailure(session, seq, error)
+        return { readable: false }
+      }
+      if (result?.supported === true) {
+        repairReadWarnings.delete(session)
+        return { readable: true, event: result.event }
+      }
+      if (result?.supported !== false) {
+        warnRepairReadFailure(session, seq, new Error('Session event reader returned an invalid capability result'))
+        return { readable: false }
+      }
+    }
+
+    // Isolated/partial Hosts that do not expose SessionQuery retain the released
+    // Session-local compatibility path. Supported production Hosts use the
+    // bounded async reader above and never silently fall back after a read error.
+    const events = legacySessionEvents(session)
+    if (!events) return { readable: false }
+    return { readable: true, event: events[seq] }
   }
 
   const keepToolResultImages = () => {
@@ -143,60 +231,85 @@ export function createSessionVisionIndex({
     return policy.ownership === 'native-image' || policy.ownership === 'vision-router-owned'
   }
 
+  const replacementIntent = (session, seq) => {
+    const intent = sessionSurfaceReplacementIntent(session, seq)
+    if (intent !== undefined) return intent
+    if (!unsupportedSurfaceContracts.has(session)) {
+      unsupportedSurfaceContracts.add(session)
+      logger?.warn?.(
+        'vision-router: skipping durable session surface repair for unsupported Session format version=%s',
+        session?.header?.version ?? 'unknown',
+      )
+    }
+    return undefined
+  }
+
   const repairToolResultSurface = async (session) => {
-    const events = sessionEvents(session)
-    if (!events || typeof session?.append !== 'function') return 0
-    const seqs = nextSurfaceSeqs(toolSurfaceScans, session)
-    if (seqs.length === 0 || typeof core.planToolResultImageShadows !== 'function') return 0
+    if (typeof session?.append !== 'function') return 0
+    const scan = pendingSurfaceScan(toolSurfaceScans, session)
+    if (!scan || typeof core.planToolResultImageShadows !== 'function') return 0
     const preserve = keepToolResultImages()
-    const plans = core.planToolResultImageShadows(events, seqs, () => !preserve)
     let repaired = 0
-    for (const plan of plans) {
-      try {
-        await session.append(
-          'tool/result',
-          { ...plan.event.data, message: plan.message },
-          {
-            surfaceOp: { op: 'replace', start: plan.seq, end: plan.seq },
-            sourceEventSeqs: [plan.seq],
-          },
-        )
-        repaired += 1
-      } catch (error) {
-        logger?.warn?.(
-          'vision-router: session tool-result surface repair failed seq=%s error=%s',
-          plan.seq,
-          boundedMessage(error),
-        )
+    for (const seq of scan.seqs) {
+      const read = await eventForSurfaceRepair(session, seq)
+      if (!read.readable) break
+      // A readable node is settled for this repair pass even when it needs no
+      // replacement or append later fails; only an unread node remains pending.
+      scan.advance()
+      const events = []
+      events[seq] = read.event
+      const plans = core.planToolResultImageShadows(events, [seq], () => !preserve)
+      for (const plan of plans) {
+        try {
+          const intent = replacementIntent(session, plan.seq)
+          if (intent === undefined) continue
+          await session.append(
+            'tool/result',
+            { ...plan.event.data, message: plan.message },
+            intent,
+          )
+          repaired += 1
+        } catch (error) {
+          logger?.warn?.(
+            'vision-router: session tool-result surface repair failed seq=%s error=%s',
+            plan.seq,
+            boundedMessage(error),
+          )
+        }
       }
     }
     return repaired
   }
 
   const repairGuardStopSurface = async (session) => {
-    const events = sessionEvents(session)
-    if (!events || typeof session?.append !== 'function') return 0
-    const seqs = nextSurfaceSeqs(guardSurfaceScans, session)
-    if (seqs.length === 0 || typeof core.planGuardStopShadows !== 'function') return 0
-    const plans = core.planGuardStopShadows(events, seqs)
+    if (typeof session?.append !== 'function') return 0
+    const scan = pendingSurfaceScan(guardSurfaceScans, session)
+    if (!scan || typeof core.planGuardStopShadows !== 'function') return 0
     let repaired = 0
-    for (const plan of plans) {
-      try {
-        await session.append(
-          'user/message',
-          plan.data,
-          {
-            surfaceOp: { op: 'replace', start: plan.seq, end: plan.seq },
-            sourceEventSeqs: [plan.seq],
-          },
-        )
-        repaired += 1
-      } catch (error) {
-        logger?.warn?.(
-          'vision-router: session guard-stop surface repair failed seq=%s error=%s',
-          plan.seq,
-          boundedMessage(error),
-        )
+    for (const seq of scan.seqs) {
+      const read = await eventForSurfaceRepair(session, seq)
+      if (!read.readable) break
+      scan.advance()
+      const events = []
+      events[seq] = read.event
+      const plans = core.planGuardStopShadows(events, [seq])
+      for (const plan of plans) {
+        try {
+          const intent = replacementIntent(session, plan.seq)
+          if (intent === undefined) continue
+          await session.append(
+            'user/message',
+            plan.data,
+            intent,
+          )
+          repaired += 1
+        } catch (error) {
+          logger?.warn?.(
+            'vision-router: session guard-stop surface repair failed seq=%s error=%s',
+            plan.seq,
+            boundedMessage(error),
+          )
+        }
       }
     }
     return repaired
@@ -213,7 +326,6 @@ export function createSessionVisionIndex({
         store.recordAttachments(session, found.attachments)
       }
     }
-    scanEventLog(session)
     await repairToolResultSurface(session)
     await repairGuardStopSurface(session)
     return decision
@@ -221,8 +333,9 @@ export function createSessionVisionIndex({
 
   return Object.freeze({
     recordAttachments,
-    scanEventLog,
     lookupAttachment,
+    resolveAttachment,
+    resolveAttachments,
     repairToolResultSurface,
     repairGuardStopSurface,
     prepareDecision,

package/lib/session-vision-mode-boundary.js

@@ -9,6 +9,7 @@ import {
 } from './session-vision-mode-authority.js'
 
 const MODE_SYNC_VARIABLE = 'vision_router_mode_sync'
+const VISION_ROUTER_TOOL_OWNER = Symbol.for('dsh-vision-router.tool-owner')
 
 function isObject(value) {
   return value !== null && typeof value === 'object'
@@ -59,6 +60,58 @@ function ownedVisionToolNames(owned) {
   return [...owned.keys()].sort()
 }
 
+function restrictableOwnedVisionToolNames(tools, owned) {
+  const names = ownedVisionToolNames(owned)
+  const get = tools?.get
+  if (typeof get !== 'function') return names
+
+  const active = []
+  for (const name of names) {
+    try {
+      // DSH restrict() accepts only names that exist in the current global
+      // registry. Logical DVR ownership is broader: an intermediate boundary
+      // may capture a conditional definition without mounting it yet
+      // (vision_screenshot is the canonical example).
+      const definition = get.call(tools, name)
+      if (definition?.[VISION_ROUTER_TOOL_OWNER] === true) active.push(name)
+    } catch {
+      // Older/partial Hosts may not offer a safely readable registry view.
+      // Preserve the historical fail-closed path there; per-name fallback
+      // below still prevents one bad entry from exposing every other tool.
+      return names
+    }
+  }
+  return active
+}
+
+function assemblyOwnedVisionToolNames(registryTools, scopedTools, owned) {
+  const active = restrictableOwnedVisionToolNames(registryTools, owned)
+  const scopedGet = scopedTools?.get
+  if (typeof scopedGet !== 'function') return new Set(active)
+
+  const projected = new Set()
+  for (const name of active) {
+    try {
+      const visible = scopedGet.call(scopedTools, name)
+      // A foreign Agent-scoped definition is allowed to shadow DVR's global
+      // name. DSH restrictions deliberately leave scoped registrations visible,
+      // so the final assembly projection must preserve the same boundary.
+      if (
+        visible === undefined
+        || visible?.[VISION_ROUTER_TOOL_OWNER] === true
+      ) {
+        projected.add(name)
+      }
+    } catch {
+      // If the scoped view cannot be read, keep the conservative global DVR
+      // projection. This support-window fallback hides only a name whose global
+      // registration is proven DVR-owned.
+      projected.add(name)
+    }
+  }
+  return projected
+}
+
 function rememberOwnedTool(owned, name) {
   owned.set(name, (owned.get(name) ?? 0) + 1)
 }
@@ -89,18 +142,30 @@ function releaseAgentToolRestriction(agent, restrictions) {
   restrictions.delete(agent)
 }
 
+function restrictionFailureLabel(error) {
+  const name =
+    typeof error?.name === 'string' && error.name !== ''
+      ? error.name
+      : 'Error'
+  const code =
+    typeof error?.code === 'string' && error.code !== ''
+      ? `/${error.code}`
+      : ''
+  return `${name}${code}`
+}
+
 function warnRestrictionFailure(agent, error, deny, failed = deny) {
   try {
     agent?.ctx?.logger?.warn?.(
-      'vision-router: failed to restrict Session vision tools while Vision mode is off: %s (deny=%s failed=%s)',
-      error?.message ?? String(error),
-      deny.join(','),
+      'vision-router: failed to restrict Session vision tools while Vision mode is off: %s (attempted=%s failed=%s)',
+      restrictionFailureLabel(error),
+      String(deny.length),
       failed.join(','),
     )
   } catch {}
 }
 
-function syncAgentToolRestriction(agent, enabled, restrictions, owned) {
+function syncAgentToolRestriction(agent, enabled, restrictions, owned, registryTools) {
   if (!isObject(agent)) return
   if (enabled) {
     releaseAgentToolRestriction(agent, restrictions)
@@ -109,7 +174,11 @@ function syncAgentToolRestriction(agent, enabled, restrictions, owned) {
 
   const tools = agent?.ctx?.tools
   const restrict = tools?.restrict
-  const deny = ownedVisionToolNames(owned)
+  // Registration truth must come from the unscoped/global registry view.
+  // agent.ctx.tools.get() is restriction-aware: after this boundary denies a
+  // DVR tool it reads as absent for that Agent, so using it here would make a
+  // later sync tear down its own restriction and re-expose the capability.
+  const deny = restrictableOwnedVisionToolNames(registryTools, owned)
   if (typeof restrict !== 'function') return
   if (deny.length === 0) {
     releaseAgentToolRestriction(agent, restrictions)
@@ -185,6 +254,7 @@ function wrapTools(tools, ctx, config, owned) {
         const execute = definition.execute
         const registered = register.call(target, {
           ...definition,
+          [VISION_ROUTER_TOOL_OWNER]: true,
           async execute(args, exec) {
             if (
               exec?.agent &&
@@ -264,6 +334,7 @@ export function installSessionVisionModeBoundary(ctx, config = {}) {
       visionToolSurfaceEnabled(ctx, config, authority),
       restrictions,
       ownedVisionTools,
+      ctx?.tools,
     )
   }
 
@@ -282,6 +353,7 @@ export function installSessionVisionModeBoundary(ctx, config = {}) {
         visionToolSurfaceEnabled(ctx, config, authority),
         restrictions,
         ownedVisionTools,
+        ctx?.tools,
       )
     }
     return authority
@@ -314,10 +386,14 @@ export function installSessionVisionModeBoundary(ctx, config = {}) {
       if (!authority && isObject(context)) authority = captureForAssembly(context)
       if (!authority && isObject(agent)) authority = resolveForAgent(agent)
       const transformed = typeof next === 'function' ? await next() : assembly
+      const projectedOwned =
+        ctx?.tools
+          ? assemblyOwnedVisionToolNames(ctx.tools, agent?.ctx?.tools, ownedVisionTools)
+          : ownedVisionTools
       return projectAssemblyTools(
         transformed,
         visionToolSurfaceEnabled(ctx, config, authority),
-        ownedVisionTools,
+        projectedOwned,
       )
     })
   } catch {
@@ -390,6 +466,7 @@ export function installSessionVisionModeBoundary(ctx, config = {}) {
               visionToolSurfaceEnabled(target, config, authority),
               restrictions,
               ownedVisionTools,
+              target?.tools,
             )
             return runWithSessionVisionModeAuthority(
               authority,

package/lib/session-vision-runtime.js

@@ -16,13 +16,17 @@ export const DEFAULT_SESSION_VISION_STATE_OPTIONS = Object.freeze({
  * It is not a general runtime service locator. Production composition creates
  * one instance and gives the same owner to the Session boundary and Core.
  *
- * Durable recovery is requested through index.lookupAttachment(); the index
- * never monkey-patches stateStore.lookupAttachment().
+ * Cache lookup stays synchronous through index.lookupAttachment(); cold durable
+ * recovery is explicit through index.resolveAttachment(). The index never
+ * monkey-patches stateStore.lookupAttachment(), and receives only narrow Host
+ * Session readers rather than the full Context.
  */
 export function createSessionVisionRuntime({
   core,
   config = {},
   logger,
+  readSessionEvent,
+  readSessionLog,
   stateStore,
   stateOptions = {},
 } = {}) {
@@ -39,6 +43,8 @@ export function createSessionVisionRuntime({
     core,
     config,
     logger,
+    readSessionEvent,
+    readSessionLog,
   })
 
   return Object.freeze({

package/lib/session-vision-state.js

@@ -123,7 +123,6 @@ function createState(key, stable, options, now) {
     attachments: new WeightedLruMap({
       maxEntries: options.attachmentMaxEntries,
     }),
-    scannedEventSeq: 0,
   }
 }
 
@@ -356,17 +355,6 @@ export function createSessionVisionStateStore(config = {}) {
       return stateFor(session, false)?.attachments.get(id)
     },
 
-    getScannedEventSeq(session) {
-      return stateFor(session, false)?.scannedEventSeq ?? 0
-    },
-
-    setScannedEventSeq(session, seq) {
-      const state = stateFor(session, true)
-      if (state === undefined) return
-      const next = Number.isFinite(Number(seq)) && Number(seq) >= 0 ? Math.floor(Number(seq)) : 0
-      state.scannedEventSeq = next
-      touchState(state)
-    },
 
     forgetSession(sessionOrId) {
       const id =
@@ -389,7 +377,6 @@ export function createSessionVisionStateStore(config = {}) {
         descriptions: state.descriptions.size,
         descriptionChars: state.descriptions.weight,
         attachments: state.attachments.size,
-        scannedEventSeq: state.scannedEventSeq,
       }
     },
 

package/lib/tesseract-exec-compat.js

@@ -1,4 +1,4 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { mkdtemp, realpath, rm, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 import { tmpdir } from 'node:os'
 import { createRequire, syncBuiltinESMExports } from 'node:module'
@@ -80,9 +80,23 @@ export function createTesseractPromisifyCompat(execFileImpl, originalCustom, opt
   const makeTempDir = options.mkdtemp ?? mkdtemp
   const writeTempFile = options.writeFile ?? writeFile
   const removeTempDir = options.rm ?? rm
+  const resolveRealPath = options.realpath ?? realpath
   const tempDir = options.tempDir ?? tmpdir()
+  let resolvedTempDir
   let active = true
 
+  const stagingRoot = async () => {
+    if (resolvedTempDir !== undefined) return resolvedTempDir
+    try {
+      resolvedTempDir = await resolveRealPath(tempDir)
+    } catch {
+      // Some tests/embedders provide a virtual temp root. Preserve the old
+      // path when canonicalization is unavailable instead of disabling OCR.
+      resolvedTempDir = tempDir
+    }
+    return resolvedTempDir
+  }
+
   async function tesseractPromisifyCompat(file, args, execOptions) {
     if (!active || !isTesseractCompatCall(file, args, execOptions)) {
       return delegate(file, args, execOptions)
@@ -91,7 +105,7 @@ export function createTesseractPromisifyCompat(execFileImpl, originalCustom, opt
     const bytes = bytesView(execOptions.input)
     let dir
     try {
-      dir = await makeTempDir(path.join(tempDir, 'dsh-vision-router-ocr-'))
+      dir = await makeTempDir(path.join(await stagingRoot(), 'dsh-vision-router-ocr-'))
       const inputPath = path.join(dir, `input${extensionForBytes(bytes)}`)
       await writeTempFile(inputPath, bytes)
 

package/lib/twin-image-capability-fallback.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from 'node:async_hooks'
+import { blocksHaveRetainedImage } from './image-offload-compat.js'
 
 const TWIN_SUFFIX = '-vision'
 const DEFAULT_MAIN_WRAPPER_ROUTE = 'deepseek-vision'
@@ -16,19 +17,9 @@ function nonEmptyString(value) {
   return typeof value === 'string' && value.length > 0
 }
 
-function blocksHaveImage(content) {
-  if (!Array.isArray(content)) return false
-  for (const block of content) {
-    if (!block) continue
-    if (block.type === 'image') return true
-    if (Array.isArray(block.content) && blocksHaveImage(block.content)) return true
-  }
-  return false
-}
-
 export function twinRequestHasImage(messages) {
   return (messages ?? []).some(
-    (message) => message && Array.isArray(message.content) && blocksHaveImage(message.content),
+    (message) => message && Array.isArray(message.content) && blocksHaveRetainedImage(message.content),
   )
 }