@juspay/neurolink 10.6.1 → 10.6.3

package/dist/lib/proxy/proxyFetch.js

@@ -509,10 +509,14 @@ async function executeProxiedFetch(input, init, proxyEnv) {
                 fetchInput = input;
             }
             const undici = await import("undici");
-            const response = await undici.fetch(fetchInput, {
+            // undici's fetch types and lib.dom's diverge on iterator helper details,
+            // so the runtime-identical response is typed as either flavor (widening
+            // assertion so control flow keeps the union) and narrowed
+            // (overlap-checked) back to the DOM flavor at the return boundary.
+            const response = (await undici.fetch(fetchInput, {
                 ...fetchInit,
                 dispatcher,
-            });
+            }));
             if (logger.shouldLog("debug")) {
                 const { parsed: responseBody, size: responseSize, type: responseType, headers: responseHeaders, } = await readResponseBody(response);
                 logger.debug("[Observability] HTTP response from LLM provider", {

package/dist/lib/rag/ChunkerFactory.js

@@ -177,7 +177,7 @@ export class ChunkerFactory extends BaseFactory {
         }, DEFAULT_CHUNKER_METADATA.latex);
         // Register semantic chunker (placeholder - uses recursive as fallback)
         this.registerChunker("semantic", async (config) => {
-            // TODO: Implement dedicated SemanticChunker with LLM support
+            // TODO(#1179): Implement dedicated SemanticChunker with LLM support
             // For now, fall back to RecursiveChunker with semantic defaults
             const { RecursiveChunker } = await import("./chunkers/RecursiveChunker.js");
             return new RecursiveChunker(config);

package/dist/lib/rag/chunking/semanticChunker.js

@@ -138,8 +138,7 @@ export class SemanticChunker {
     async getEmbeddings(segments, provider, modelName) {
         const embeddingProvider = await ProviderFactory.createProvider(provider, modelName);
         // Check if provider has embed method
-        if (typeof embeddingProvider.embed !==
-            "function") {
+        if (typeof embeddingProvider.embed !== "function") {
             throw new Error(`Provider ${provider} does not support embeddings`);
         }
         const embeddings = [];

package/dist/lib/rag/document/MDocument.js

@@ -210,8 +210,7 @@ export class MDocument {
             model: modelName,
         });
         const embeddingProvider = await ProviderFactory.createProvider(provider, modelName);
-        if (typeof embeddingProvider.embed !==
-            "function") {
+        if (typeof embeddingProvider.embed !== "function") {
             throw new Error(`Provider ${provider} does not support embeddings`);
         }
         this.state.embeddings = [];

package/dist/lib/rag/document/loaders.js

@@ -273,14 +273,27 @@ export class PDFLoader {
         return ext === ".pdf";
     }
     async loadPdfParser() {
+        // pdf-parse is an optional dependency — resolve it dynamically and
+        // validate at runtime that it exposes a callable parser (either the
+        // module itself or its default export) instead of blindly asserting.
+        let pdfParseModule;
         try {
-            // pdf-parse is an optional dependency - use dynamic import with type assertion
-            const pdfParse = (await import("pdf-parse"));
-            return pdfParse.default || pdfParse;
+            pdfParseModule = await import("pdf-parse");
         }
         catch {
             throw new Error("pdf-parse module not available");
         }
+        const candidate = (typeof pdfParseModule === "object" &&
+            pdfParseModule !== null &&
+            "default" in pdfParseModule
+            ? pdfParseModule.default
+            : undefined) || pdfParseModule;
+        if (typeof candidate !== "function") {
+            // Outside the try/catch so this message isn't swallowed by the
+            // module-not-available rethrow.
+            throw new Error("pdf-parse module does not export a parse function");
+        }
+        return candidate;
     }
     parsePageRange(range, totalPages) {
         const pages = [];

package/dist/lib/rag/pipeline/RAGPipeline.js

@@ -371,8 +371,7 @@ export class RAGPipeline {
         if (!this.embeddingProvider) {
             throw new Error("Embedding provider not initialized");
         }
-        if (typeof this.embeddingProvider
-            .embed !== "function") {
+        if (typeof this.embeddingProvider.embed !== "function") {
             throw new Error(`Provider ${this.config.embeddingModel.provider} does not support embeddings`);
         }
         return await withTimeout(this.embeddingProvider.embed(text), DEFAULT_TIMEOUT_MS, "Embedding generation timed out");

package/dist/lib/rag/retrieval/hybridSearch.js

@@ -177,8 +177,7 @@ export function createHybridSearch(options) {
         try {
             // Generate query embedding
             const embeddingProvider = await ProviderFactory.createProvider(embeddingModel?.provider, embeddingModel?.modelName);
-            if (typeof embeddingProvider
-                .embed !== "function") {
+            if (typeof embeddingProvider.embed !== "function") {
                 throw new Error(`Embedding provider does not support the embed() method. ` +
                     `Please use a provider that supports embeddings (e.g., OpenAI text-embedding-3-small, Vertex text-embedding-004).`);
             }

package/dist/lib/rag/retrieval/vectorQueryTool.js

@@ -66,8 +66,7 @@ export function createVectorQueryTool(config, vectorStore) {
                     // Generate query embedding
                     const embeddingProvider = await ProviderFactory.createProvider(embeddingModel.provider, embeddingModel.modelName);
                     // Check if provider has embed method
-                    if (typeof embeddingProvider
-                        .embed !== "function") {
+                    if (typeof embeddingProvider.embed !== "function") {
                         throw new Error(`Provider ${embeddingModel.provider} does not support embeddings`);
                     }
                     const queryEmbedding = await embeddingProvider.embed(params.query);

package/dist/lib/sdk/toolRegistration.js

@@ -250,8 +250,12 @@ export function validateTool(name, tool) {
             throw new Error(`Tool '${name}' parameters must be an object. ` +
                 `Received: ${typeof tool.parameters}`);
         }
-        // Check for common schema validation methods (Zod uses 'parse', others might use 'validate')
-        const params = tool.parameters;
+        // Check for common schema validation methods (Zod uses 'parse', others might use 'validate').
+        // Despite the declared Zod type, callers may pass custom schema objects at
+        // runtime — this function's whole purpose is to validate that; probe as
+        // `unknown` and narrow to a generic record for feature detection.
+        const paramsCandidate = tool.parameters;
+        const params = paramsCandidate;
         const hasValidationMethod = typeof params.parse === "function" ||
             typeof params.validate === "function" ||
             "_def" in params; // Zod schemas have _def property

package/dist/lib/server/middleware/cache.d.ts

@@ -83,6 +83,10 @@ export declare class LRUCache<K, V> {
      * Check if a key exists in the cache
      */
     has(key: K): boolean;
+    /**
+     * Iterate over all keys currently in the cache
+     */
+    keys(): IterableIterator<K>;
     /**
      * Delete a key from the cache
      */

package/dist/lib/server/middleware/cache.js

@@ -219,6 +219,12 @@ export class LRUCache {
     has(key) {
         return this.cache.has(key);
     }
+    /**
+     * Iterate over all keys currently in the cache
+     */
+    keys() {
+        return this.cache.keys();
+    }
     /**
      * Delete a key from the cache
      */
@@ -335,9 +341,7 @@ export class ResponseCacheStore {
         // For production, consider using a more efficient data structure
         let invalidated = 0;
         const keysToDelete = [];
-        // Get all keys (requires accessing internal cache)
-        const internalCache = this.cache.cache;
-        for (const key of internalCache.keys()) {
+        for (const key of this.cache.keys()) {
             const matches = pattern instanceof RegExp ? pattern.test(key) : key.includes(pattern);
             if (matches) {
                 keysToDelete.push(key);

package/dist/lib/server/middleware/validation.js

@@ -75,7 +75,8 @@ export function createRequestValidationMiddleware(config) {
                 const formattedError = errorFormatter(errors.map((e) => new ServerValidationError([e], ctx.requestId)));
                 const error = new ServerValidationError(errors, ctx.requestId);
                 // Attach formatted response to error
-                error.response = formattedError;
+                error.response =
+                    formattedError;
                 throw error;
             }
             return next();

package/dist/lib/server/utils/redaction.js

@@ -80,13 +80,13 @@ function redactChunkByType(chunk, redactedFields, placeholder, config) {
     const chunkType = typedChunk.type;
     switch (chunkType) {
         case "step-start":
-            return redactStepStart(typedChunk, redactedFields, placeholder);
+            return redactStepStart(chunk, redactedFields, placeholder);
         case "tool-call":
-            return redactToolCall(typedChunk, redactedFields, placeholder, config);
+            return redactToolCall(chunk, redactedFields, placeholder, config);
         case "tool-result":
-            return redactToolResult(typedChunk, redactedFields, placeholder, config);
+            return redactToolResult(chunk, redactedFields, placeholder, config);
         case "error":
-            return redactError(typedChunk, redactedFields, placeholder);
+            return redactError(chunk, redactedFields, placeholder);
         default:
             return redactGenericChunk(typedChunk, redactedFields, placeholder);
     }
@@ -99,13 +99,12 @@ function redactStepStart(chunk, redactedFields, placeholder) {
         return chunk;
     }
     const { payload, ...rest } = chunk;
-    const payloadObj = payload;
-    const redactedPayload = redactObject(payloadObj, redactedFields, placeholder, 0);
-    return {
+    const redactedPayload = redactObject(payload, redactedFields, placeholder, 0);
+    const redacted = {
         ...rest,
-        type: "step-start",
         payload: redactedPayload,
     };
+    return redacted;
 }
 /**
  * Redact tool-call chunks
@@ -114,49 +113,45 @@ function redactToolCall(chunk, redactedFields, placeholder, config) {
     // Handle chunks with payload structure
     if (hasPayload(chunk)) {
         const { payload, ...rest } = chunk;
-        const payloadObj = payload;
         // Redact tool arguments if configured
-        if (payloadObj.toolCall && typeof payloadObj.toolCall === "object") {
-            const toolCall = payloadObj.toolCall;
+        if (payload.toolCall && typeof payload.toolCall === "object") {
+            const toolCall = payload.toolCall;
             const redactArgs = config?.redactToolArgs !== false && redactedFields.has("args");
-            return {
+            const redacted = {
                 ...rest,
-                type: "tool-call",
                 payload: {
-                    ...payloadObj,
+                    ...payload,
                     toolCall: {
                         ...toolCall,
                         args: redactArgs ? placeholder : toolCall.args,
                     },
                 },
             };
+            return redacted;
         }
-        return {
+        const redacted = {
             ...rest,
-            type: "tool-call",
-            payload: redactObject(payloadObj, redactedFields, placeholder, 0),
+            payload: redactObject(payload, redactedFields, placeholder, 0),
         };
+        return redacted;
     }
     // Handle chunks with data structure (DataStreamEvent format)
     if (hasData(chunk)) {
         const { data, ...rest } = chunk;
-        const dataObj = data;
         const redactArgs = config?.redactToolArgs !== false && redactedFields.has("args");
         // Check for arguments field in data
-        if ("arguments" in dataObj && redactArgs) {
+        if ("arguments" in data && redactArgs) {
             return {
                 ...rest,
-                type: "tool-call",
                 data: {
-                    ...dataObj,
+                    ...data,
                     arguments: placeholder,
                 },
             };
         }
         return {
             ...rest,
-            type: "tool-call",
-            data: redactObject(dataObj, redactedFields, placeholder, 0),
+            data: redactObject(data, redactedFields, placeholder, 0),
         };
     }
     return chunk;
@@ -169,26 +164,23 @@ function redactToolResult(chunk, redactedFields, placeholder, config) {
     // Handle chunks with payload structure
     if (hasPayload(chunk)) {
         const { payload, ...rest } = chunk;
-        const payloadObj = payload;
-        return {
+        const redacted = {
             ...rest,
-            type: "tool-result",
             payload: {
-                ...payloadObj,
-                result: redactResult ? placeholder : payloadObj.result,
+                ...payload,
+                result: redactResult ? placeholder : payload.result,
             },
         };
+        return redacted;
     }
     // Handle chunks with data structure (DataStreamEvent format)
     if (hasData(chunk)) {
         const { data, ...rest } = chunk;
-        const dataObj = data;
         return {
             ...rest,
-            type: "tool-result",
             data: {
-                ...dataObj,
-                result: redactResult ? placeholder : dataObj.result,
+                ...data,
+                result: redactResult ? placeholder : data.result,
             },
         };
     }
@@ -202,11 +194,9 @@ function redactError(chunk, redactedFields, placeholder) {
     // Handle chunks with data structure (DataStreamEvent format)
     if (hasData(chunk)) {
         const { data, ...rest } = chunk;
-        const dataObj = data;
-        const { stack, ...dataRest } = dataObj;
+        const { stack, ...dataRest } = data;
         return {
             ...rest,
-            type: "error",
             data: {
                 ...redactObject(dataRest, redactedFields, placeholder, 0),
                 ...(isProduction ? {} : { stack }),
@@ -214,7 +204,8 @@ function redactError(chunk, redactedFields, placeholder) {
         };
     }
     // Handle direct chunk with stack
-    const { stack, ...restChunk } = chunk;
+    const chunkRecord = chunk;
+    const { stack, ...restChunk } = chunkRecord;
     const redactedRest = redactObject(restChunk, redactedFields, placeholder, 0);
     return {
         ...redactedRest,
@@ -270,9 +261,10 @@ function redactObject(obj, redactedFields, placeholder, depth) {
  * Type guard for chunks with payload
  */
 function hasPayload(chunk) {
-    return ("payload" in chunk &&
-        chunk.payload !== null &&
-        typeof chunk.payload === "object");
+    const record = chunk;
+    return ("payload" in record &&
+        record.payload !== null &&
+        typeof record.payload === "object");
 }
 /**
  * Type guard for chunks with data (DataStreamEvent format)

package/dist/lib/server/websocket/WebSocketHandler.js

@@ -334,17 +334,17 @@ export function createAgentWebSocketHandler(_neurolink) {
     // Register message routes
     router.route("generate", async (connection, payload) => {
         const { prompt, options: _options } = payload;
-        // TODO: Implement generate using neurolink
+        // TODO(#1179): Implement generate using neurolink
         return { type: "response", data: `Received: ${prompt}` };
     });
     router.route("stream", async (connection, payload) => {
         const { prompt, options: _options } = payload;
-        // TODO: Implement streaming using neurolink
+        // TODO(#1179): Implement streaming using neurolink
         return { type: "stream_start", data: { prompt } };
     });
     router.route("tool_call", async (connection, payload) => {
         const { toolName, args: _args } = payload;
-        // TODO: Implement tool call using neurolink
+        // TODO(#1179): Implement tool call using neurolink
         return { type: "tool_result", data: { toolName, result: null } };
     });
     return {

package/dist/lib/services/server/ai/observability/instrumentation.js

@@ -225,6 +225,7 @@ class ContextEnricher {
         const userId = context?.userId ?? currentConfig?.userId ?? "guest";
         const sessionId = context?.sessionId ?? currentConfig?.sessionId;
         // Get span name for operation auto-detection
+        // (sdk-trace-base's Span type includes the ReadableSpan members)
         const spanName = span.name;
         // Determine if auto-detection is enabled for this context
         const autoDetect = this.shouldAutoDetectOperationName(context);
@@ -386,9 +387,11 @@ class ContextEnricher {
      */
     onEnd(span) {
         try {
-            // Get span attributes (ReadableSpan interface)
-            const readableSpan = span;
-            const attributes = readableSpan.attributes || {};
+            // Get span attributes (sdk-trace-base's Span type includes the
+            // ReadableSpan members, so attributes/name/status are directly typed).
+            // Keep the {} fallback: this processor can be attached to an external
+            // app-owned TracerProvider whose span implementation may omit attributes.
+            const attributes = span.attributes ?? {};
             // Handle wrapper/trace-root spans: update trace name with detected operation
             // This supports host apps (like Curator) that create wrapper spans before AI calls
             // This is optional - if spanContext fails, we skip wrapper span support
@@ -437,7 +440,7 @@ class ContextEnricher {
                 const provider = attributes["gen_ai.system"] ||
                     attributes["ai.model.provider"];
                 logger.debug(`${LOG_PREFIX} GenAI span detected`, {
-                    spanName: readableSpan.name,
+                    spanName: span.name,
                     model,
                     provider,
                 });
@@ -529,7 +532,7 @@ class ContextEnricher {
                 // *returns* { isError:true } (no exception thrown), so Langfuse sees
                 // level=DEFAULT and no status message. Parse the stringified result
                 // and surface the embedded error text.
-                if (readableSpan.name === "ai.toolCall" &&
+                if (span.name === "ai.toolCall" &&
                     readableStatus?.code !== SpanStatusCode.ERROR) {
                     applyToolCallIsErrorStatus(mutableAttrs);
                 }

package/dist/lib/types/classifierRouter.d.ts

@@ -13,6 +13,7 @@
  * Type names are domain-prefixed `Classifier*` to stay globally unique across
  * `src/lib/types/` (see CLAUDE.md rule 9).
  */
+import type { ValidationSchema } from "./aliases.js";
 /** Coarse difficulty buckets the classifier maps a request into. */
 export type ClassifierDifficulty = "trivial" | "simple" | "moderate" | "hard" | "expert";
 /** Which classification strategy to run. */
@@ -166,7 +167,7 @@ export type ClassifierGenerateOptions = {
     temperature?: number;
     maxTokens?: number;
     disableTools?: boolean;
-    schema?: unknown;
+    schema?: ValidationSchema;
     timeout?: number | string;
     context?: Record<string, unknown>;
 };

package/dist/lib/types/cli.d.ts

@@ -637,15 +637,15 @@ export type CLIMCPServerConfig = {
  * OpenAI setup configuration types
  */
 export declare namespace OpenAISetup {
-    type SetupOptions = {
+    type OpenAISetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
     };
-    type SetupArgv = {
+    type OpenAISetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
     };
-    type Config = {
+    type OpenAISetupConfig = {
         apiKey?: string;
         organization?: string;
         model?: string;
@@ -656,15 +656,15 @@ export declare namespace OpenAISetup {
  * Anthropic setup configuration types
  */
 export declare namespace AnthropicSetup {
-    type SetupOptions = {
+    type AnthropicSetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
     };
-    type SetupArgv = {
+    type AnthropicSetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
     };
-    type Config = {
+    type AnthropicSetupConfig = {
         apiKey?: string;
         model?: string;
         isReconfiguring?: boolean;
@@ -674,15 +674,15 @@ export declare namespace AnthropicSetup {
  * Google AI setup configuration types
  */
 export declare namespace GoogleAISetup {
-    type SetupOptions = {
+    type GoogleAISetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
     };
-    type SetupArgv = {
+    type GoogleAISetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
     };
-    type Config = {
+    type GoogleAISetupConfig = {
         apiKey?: string;
         model?: string;
         isReconfiguring?: boolean;
@@ -692,15 +692,15 @@ export declare namespace GoogleAISetup {
  * Azure setup configuration types
  */
 export declare namespace AzureSetup {
-    type SetupOptions = {
+    type AzureSetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
     };
-    type SetupArgv = {
+    type AzureSetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
     };
-    type Config = {
+    type AzureSetupConfig = {
         apiKey?: string;
         endpoint?: string;
         deploymentName?: string;
@@ -713,11 +713,11 @@ export declare namespace AzureSetup {
  * AWS Bedrock setup configuration types
  */
 export declare namespace BedrockSetup {
-    type SetupOptions = {
+    type BedrockSetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
     };
-    type SetupArgv = {
+    type BedrockSetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
     };
@@ -738,11 +738,11 @@ export declare namespace BedrockSetup {
  * GCP/Vertex AI setup configuration types
  */
 export declare namespace GCPSetup {
-    type SetupOptions = {
+    type GCPSetupOptions = {
         checkOnly?: boolean;
         interactive?: boolean;
     };
-    type SetupArgv = {
+    type GCPSetupArgv = {
         check?: boolean;
         nonInteractive?: boolean;
     };
@@ -757,7 +757,7 @@ export declare namespace GCPSetup {
  * Hugging Face setup configuration types
  */
 export declare namespace HuggingFaceSetup {
-    type SetupArgs = {
+    type HuggingFaceSetupArgs = {
         check?: boolean;
         nonInteractive?: boolean;
         help?: boolean;
@@ -767,7 +767,7 @@ export declare namespace HuggingFaceSetup {
  * Mistral setup configuration types
  */
 export declare namespace MistralSetup {
-    type SetupArgs = {
+    type MistralSetupArgs = {
         check?: boolean;
         nonInteractive?: boolean;
         help?: boolean;

package/dist/lib/types/providers.d.ts

@@ -2,6 +2,7 @@
  * Provider-specific type definitions for NeuroLink
  */
 import type { UnknownRecord, JsonValue, StreamingCapability } from "./common.js";
+import type { NeuroLink } from "../neurolink.js";
 import { AIProviderName, AnthropicModels, BedrockModels, DeepSeekModels, GoogleAIModels, LlamaCppModels, LMStudioModels, NvidiaNimModels, OpenAIModels, VertexModels } from "../constants/enums.js";
 import type { ValidationSchema } from "./aliases.js";
 import type { EnhancedGenerateResult, GenerateResult, TextGenerationOptions } from "./generate.js";
@@ -1478,7 +1479,7 @@ export type ProviderHealthCheckOptions = {
  * Amazon Bedrock specific types
  */
 export declare namespace BedrockTypes {
-    type Client = {
+    type BedrockClient = {
         send(command: unknown): Promise<unknown>;
         config: {
             region?: string;
@@ -1497,7 +1498,7 @@ export declare namespace BedrockTypes {
  * Mistral specific types
  */
 export declare namespace MistralTypes {
-    type Client = {
+    type MistralClient = {
         chat?: {
             complete?: (options: unknown) => Promise<unknown>;
             stream?: (options: unknown) => AsyncIterable<unknown>;
@@ -1669,8 +1670,8 @@ export type ToolWithLegacyParams = {
  * factory functions.
  */
 export type ProviderConstructor = {
-    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string, credentials?: UnknownRecord): AIProvider;
-} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string, credentials?: UnknownRecord) => Promise<AIProvider>);
+    new (modelName?: string, providerName?: string, sdk?: NeuroLink, region?: string, credentials?: UnknownRecord): AIProvider;
+} | ((modelName?: string, providerName?: string, sdk?: NeuroLink, region?: string, credentials?: UnknownRecord) => Promise<AIProvider>);
 /** Provider registration entry held by ProviderFactory. */
 export type ProviderRegistration = {
     constructor: ProviderConstructor;
@@ -1779,6 +1780,25 @@ export type VertexNativePart = {
         data: string;
     };
 };
+/**
+ * Part variants that ride the native Gemini agentic tool loop in addition to
+ * the plain `VertexNativePart` content shapes: model-issued function calls
+ * replayed into history, and the function responses (plus wrap-up nudge text
+ * parts) sent back on the next user turn. Mirrors the optional
+ * `functionCall` / `functionResponse` members of the @google/genai SDK's
+ * `Part` type, so loop contents stay directly assignable to the SDK payload.
+ */
+export type VertexNativeLoopPart = VertexNativePart | {
+    functionCall: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+} | {
+    functionResponse: {
+        name: string;
+        response: Record<string, unknown>;
+    };
+};
 /**
  * Subset of `GenerateOptions["input"]` consumed by the shared Gemini-native
  * multimodal-parts builder. Kept narrow so the helper doesn't depend on the

package/dist/lib/utils/pdfProcessor.js

@@ -264,6 +264,8 @@ export class PDFProcessor {
                     clearTimeout(timeoutHandle);
                 }
                 try {
+                    // Optional call: guards against a runtime pdf-parse version whose
+                    // instances lack destroy(), while the typed v2 class declares it.
                     await pdf.destroy?.();
                 }
                 catch {

package/dist/lib/utils/safeFetch.js

@@ -58,6 +58,23 @@ function buildPinnedAgent(hostname, addresses) {
         },
     });
 }
+/**
+ * Runtime-validating narrow across the undici → DOM `Response` type boundary.
+ * `readBoundedBuffer` only touches `headers.get()` and `arrayBuffer()`; the
+ * two libraries' `Response` declarations disagree on unrelated members
+ * (headers iterator shapes), so validate the members actually used instead
+ * of blindly asserting.
+ */
+function isBoundedBufferResponse(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.arrayBuffer === "function" &&
+        typeof candidate.headers === "object" &&
+        candidate.headers !== null &&
+        typeof candidate.headers.get === "function");
+}
 /**
  * Safely download a binary asset from an external URL.
  *
@@ -96,6 +113,9 @@ export async function safeDownload(url, options) {
     }
     // readBoundedBuffer expects a Response that exposes Content-Length and
     // arrayBuffer(). undici Response satisfies both.
+    if (!isBoundedBufferResponse(response)) {
+        throw new Error(`safeDownload(${options.label}): response is missing headers.get()/arrayBuffer()`);
+    }
     return readBoundedBuffer(response, options.maxBytes, options.label);
 }
 //# sourceMappingURL=safeFetch.js.map