dsh-vision-router 2.3.0 → 3.0.1

package/lib/http-body-limit.js

@@ -1,98 +1,116 @@
-const DEFAULT_FALLBACK_MAX_BYTES = 4 * 1024 * 1024
-
-export const MODEL_RESPONSE_MAX_BYTES = 4 * 1024 * 1024
-export const METADATA_RESPONSE_MAX_BYTES = 512 * 1024
-export const ERROR_RESPONSE_MAX_BYTES = 64 * 1024
-export const DOCTOR_RESPONSE_MAX_BYTES = 16 * 1024
-
+const DEFAULT_FALLBACK_MAX_BYTES = 4 * 1024 * 1024;
+export const MODEL_RESPONSE_MAX_BYTES = 4 * 1024 * 1024;
+export const METADATA_RESPONSE_MAX_BYTES = 512 * 1024;
+export const ERROR_RESPONSE_MAX_BYTES = 64 * 1024;
+export const DOCTOR_RESPONSE_MAX_BYTES = 16 * 1024;
+function responseLike(value) {
+    return value !== null && typeof value === 'object'
+        ? value
+        : {};
+}
 function normalizedLimit(value) {
-  const number = Number(value)
-  return Number.isSafeInteger(number) && number > 0 ? number : DEFAULT_FALLBACK_MAX_BYTES
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : DEFAULT_FALLBACK_MAX_BYTES;
 }
-
 function responseTooLarge(label, limit, observed) {
-  const suffix = Number.isFinite(observed) ? ` (observed ${observed} bytes)` : ''
-  const error = new Error(`${label} exceeds the ${limit}-byte response limit${suffix}`)
-  error.code = 'HTTP_RESPONSE_TOO_LARGE'
-  error.maxBytes = limit
-  if (Number.isFinite(observed)) error.observedBytes = observed
-  return error
+    const suffix = Number.isFinite(observed) ? ` (observed ${observed} bytes)` : '';
+    const error = new Error(`${label} exceeds the ${limit}-byte response limit${suffix}`);
+    error.code = 'HTTP_RESPONSE_TOO_LARGE';
+    error.maxBytes = limit;
+    if (typeof observed === 'number' && Number.isFinite(observed))
+        error.observedBytes = observed;
+    return error;
 }
-
 function declaredLength(response) {
-  const raw = response?.headers?.get?.('content-length')
-  if (raw === null || raw === undefined || raw === '') return undefined
-  const value = Number(raw)
-  return Number.isFinite(value) && value >= 0 ? value : undefined
+    const raw = responseLike(response).headers?.get?.('content-length');
+    if (raw === null || raw === undefined || raw === '')
+        return undefined;
+    const value = Number(raw);
+    return Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function chunkBytes(value) {
+    if (value instanceof Uint8Array)
+        return value;
+    return new Uint8Array((value ?? []));
 }
-
 /**
  * Consume one HTTP response body with a hard byte ceiling enforced while the
  * stream is read. Content-Length is only a preflight: fetch may transparently
  * decompress a response, so the decoded body stream is independently counted.
  */
 export async function readResponseBytesBounded(response, maxBytes, options = {}) {
-  const limit = normalizedLimit(maxBytes)
-  const label = typeof options.label === 'string' && options.label !== '' ? options.label : 'HTTP response'
-  const declared = declaredLength(response)
-  if (declared !== undefined && declared > limit) {
-    try { await response?.body?.cancel?.('response body limit exceeded') } catch { /* best effort */ }
-    throw responseTooLarge(label, limit, declared)
-  }
-
-  const body = response?.body
-  if (body && typeof body.getReader === 'function') {
-    const reader = body.getReader()
-    const chunks = []
-    let total = 0
-    try {
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
-        const bytes = value instanceof Uint8Array ? value : new Uint8Array(value ?? [])
-        if (total + bytes.byteLength > limit) {
-          try { await reader.cancel('response body limit exceeded') } catch { /* best effort */ }
-          throw responseTooLarge(label, limit, total + bytes.byteLength)
+    const limit = normalizedLimit(maxBytes);
+    const label = typeof options.label === 'string' && options.label !== '' ? options.label : 'HTTP response';
+    const declared = declaredLength(response);
+    const readable = responseLike(response);
+    if (declared !== undefined && declared > limit) {
+        try {
+            await readable.body?.cancel?.('response body limit exceeded');
+        }
+        catch { /* best effort */ }
+        throw responseTooLarge(label, limit, declared);
+    }
+    const body = readable.body;
+    if (body && typeof body.getReader === 'function') {
+        const reader = body.getReader();
+        const chunks = [];
+        let total = 0;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const bytes = chunkBytes(value);
+                if (total + bytes.byteLength > limit) {
+                    try {
+                        await reader.cancel?.('response body limit exceeded');
+                    }
+                    catch { /* best effort */ }
+                    throw responseTooLarge(label, limit, total + bytes.byteLength);
+                }
+                total += bytes.byteLength;
+                chunks.push(Buffer.from(bytes));
+            }
+            return Buffer.concat(chunks, total);
+        }
+        finally {
+            try {
+                reader.releaseLock?.();
+            }
+            catch { /* best effort */ }
         }
-        total += bytes.byteLength
-        chunks.push(Buffer.from(bytes))
-      }
-      return Buffer.concat(chunks, total)
-    } finally {
-      try { reader.releaseLock() } catch { /* best effort */ }
     }
-  }
-
-  // Synthetic test doubles may expose text()/arrayBuffer() without a WHATWG
-  // body stream. Real Node fetch responses take the streaming path above, so
-  // this compatibility fallback is not the production admission boundary.
-  if (typeof response?.arrayBuffer === 'function') {
-    const bytes = Buffer.from(await response.arrayBuffer())
-    if (bytes.length > limit) throw responseTooLarge(label, limit, bytes.length)
-    return bytes
-  }
-  if (typeof response?.text === 'function') {
-    const text = await response.text()
-    const bytes = Buffer.from(String(text ?? ''), 'utf8')
-    if (bytes.length > limit) throw responseTooLarge(label, limit, bytes.length)
-    return bytes
-  }
-  throw new Error(`${label} has no readable response body`)
+    // Synthetic test doubles may expose text()/arrayBuffer() without a WHATWG
+    // body stream. Real Node fetch responses take the streaming path above, so
+    // this compatibility fallback is not the production admission boundary.
+    if (typeof readable.arrayBuffer === 'function') {
+        const bytes = Buffer.from(await readable.arrayBuffer());
+        if (bytes.length > limit)
+            throw responseTooLarge(label, limit, bytes.length);
+        return bytes;
+    }
+    if (typeof readable.text === 'function') {
+        const text = await readable.text();
+        const bytes = Buffer.from(String(text ?? ''), 'utf8');
+        if (bytes.length > limit)
+            throw responseTooLarge(label, limit, bytes.length);
+        return bytes;
+    }
+    throw new Error(`${label} has no readable response body`);
 }
-
 export async function readResponseTextBounded(response, maxBytes, options = {}) {
-  return (await readResponseBytesBounded(response, maxBytes, options)).toString('utf8')
+    return (await readResponseBytesBounded(response, maxBytes, options)).toString('utf8');
 }
-
 export async function readResponseJsonBounded(response, maxBytes, options = {}) {
-  const label = typeof options.label === 'string' && options.label !== '' ? options.label : 'HTTP response'
-  const text = await readResponseTextBounded(response, maxBytes, options)
-  try {
-    return JSON.parse(text)
-  } catch (cause) {
-    const error = new Error(`${label} returned invalid JSON`)
-    error.code = 'HTTP_RESPONSE_INVALID_JSON'
-    error.cause = cause
-    throw error
-  }
+    const label = typeof options.label === 'string' && options.label !== '' ? options.label : 'HTTP response';
+    const text = await readResponseTextBounded(response, maxBytes, options);
+    try {
+        return JSON.parse(text);
+    }
+    catch (cause) {
+        const error = new Error(`${label} returned invalid JSON`);
+        error.code = 'HTTP_RESPONSE_INVALID_JSON';
+        error.cause = cause;
+        throw error;
+    }
 }

package/lib/image-offload-compat.js

@@ -1,25 +1,34 @@
+function objectRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
 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)
+    const attachment = objectRecord(objectRecord(block)?.attachment);
+    const raw = 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
+    const value = objectRecord(block);
+    return value?.type === 'image' && value.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
+    if (!Array.isArray(content))
+        return false;
+    for (const block of content) {
+        const value = objectRecord(block);
+        if (value === undefined)
+            continue;
+        if (value.type === 'image' && value.offloaded !== true)
+            return true;
+        if (Array.isArray(value.content) && blocksHaveRetainedImage(value.content))
+            return true;
+    }
+    return false;
 }
-
 /**
  * Dependency-free model-facing placeholder for an image DSH already offloaded.
  *
@@ -29,10 +38,10 @@ export function blocksHaveRetainedImage(content) {
  * 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)}].]`
+    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)}].]`;
 }