refactor: better normalized llm http response handling (#106)

Author: gitcommitshow

lib/ResilientLLM.ts

@@ -825,9 +825,7 @@ class ResilientLLM {
 
             console.log("Response Headers:", response?.headers);
 
-            const data = await response?.json() as Record<string, unknown>;
-
-            const result: HttpResult = { data, statusCode: response?.status };
+            const result = await ResilientLLM._readProviderJsonResponse(response);
 
             const httpDurationMs = Date.now() - httpStartTime;
             console.log(`Request to ${apiUrl} completed in ${httpDurationMs} ms`);
@@ -853,6 +851,80 @@ class ResilientLLM {
         }
     }
 
+    /**
+     * Reads a provider response as JSON when possible, otherwise returns a synthetic JSON error payload.
+     */
+    static async _readProviderJsonResponse(response: Response): Promise<HttpResult> {
+        const statusCode = response?.status ?? 0;
+        const contentType = response?.headers?.get?.('content-type') || '';
+        const normalizedContentType = contentType.toLowerCase();
+        const isJson = normalizedContentType.includes('application/json') || normalizedContentType.includes('+json');
+        const responseLike = response as Response & {
+            text?: () => Promise<string>;
+            json?: () => Promise<unknown>;
+        };
+
+        // Prefer text() when available to keep a single, controlled body parse path.
+        if (typeof responseLike.text === 'function') {
+            const raw = await responseLike.text().catch(() => '');
+            const snippet = (raw || '').slice(0, 2000);
+
+            if (isJson) {
+                try {
+                    const parsed = raw ? (JSON.parse(raw) as Record<string, unknown>) : ({} as Record<string, unknown>);
+                    return { data: parsed, statusCode };
+                } catch {
+                    return {
+                        statusCode,
+                        data: {
+                            error: {
+                                message: `Invalid JSON from provider (HTTP ${statusCode}). ${snippet ? `Body: ${snippet}` : 'Empty body.'}`,
+                            },
+                        },
+                    };
+                }
+            }
+
+            return {
+                statusCode,
+                data: {
+                    error: {
+                        message: `Expected JSON from provider but received "${contentType || 'unknown'}" (HTTP ${statusCode}). ${snippet ? `Body: ${snippet}` : 'Empty body.'}`,
+                    },
+                },
+            };
+        }
+
+        // Compatibility fallback for partial/mock responses that only expose json().
+        if (typeof responseLike.json === 'function') {
+            try {
+                const parsed = await responseLike.json();
+                return {
+                    statusCode,
+                    data: (parsed ?? {}) as Record<string, unknown>,
+                };
+            } catch {
+                return {
+                    statusCode,
+                    data: {
+                        error: {
+                            message: `Invalid JSON from provider (HTTP ${statusCode}). Empty body.`,
+                        },
+                    },
+                };
+            }
+        }
+
+        return {
+            statusCode,
+            data: {
+                error: {
+                    message: `Expected JSON from provider but received "${contentType || 'unknown'}" (HTTP ${statusCode}). Empty body.`,
+                },
+            },
+        };
+    }
+
     static _captureHttpMetadata(
         metadata: OperationMetadata,
         apiUrl: string,

test/resilient-llm.unit.test.js

@@ -48,6 +48,43 @@ describe('ResilientLLM Unit Tests', () => {
         sinon.restore();
     });
 
+    describe('Provider response JSON reader', () => {
+        it('returns parsed data when mock response only implements json()', async () => {
+            const result = await ResilientLLM._readProviderJsonResponse({
+                status: 200,
+                headers: { get: () => null },
+                json: async () => ({ choices: [{ message: { content: 'ok' } }] }),
+            });
+
+            expect(result.statusCode).to.equal(200);
+            expect(result.data).to.deep.equal({ choices: [{ message: { content: 'ok' } }] });
+        });
+
+        it('returns synthetic error payload when provider responds with non-json text body', async () => {
+            const result = await ResilientLLM._readProviderJsonResponse({
+                status: 502,
+                headers: { get: () => 'text/html; charset=utf-8' },
+                text: async () => '<html>Bad Gateway</html>',
+            });
+
+            expect(result.statusCode).to.equal(502);
+            expect(result.data?.error?.message).to.include('Expected JSON from provider');
+            expect(result.data?.error?.message).to.include('text/html');
+        });
+
+        it('returns synthetic error payload when provider sends invalid json body', async () => {
+            const result = await ResilientLLM._readProviderJsonResponse({
+                status: 500,
+                headers: { get: () => 'application/json' },
+                text: async () => '{"broken": ',
+            });
+
+            expect(result.statusCode).to.equal(500);
+            expect(result.data?.error?.message).to.include('Invalid JSON from provider');
+            expect(result.data?.error?.message).to.include('Body: {"broken": ');
+        });
+    });
+
     describe('Happy Path Tests', () => {
         it('should successfully complete a chat request and return parsed response', async () => {
             // Arrange