call-ai 0.7.0-dev-preview-9 → 0.7.0-dev-preview-12

package/dist/api.js

@@ -35,10 +35,26 @@ function callAI(prompt, options = {}) {
         // Make the fetch request and handle errors before creating the generator
         console.log(`[callAI:${PACKAGE_VERSION}] Making fetch request to: ${endpoint}`);
         console.log(`[callAI:${PACKAGE_VERSION}] With model: ${model}`);
+        console.log(`[callAI:${PACKAGE_VERSION}] Request headers:`, JSON.stringify(requestOptions.headers));
         let response;
         try {
             response = await fetch(endpoint, requestOptions);
             console.log(`[callAI:${PACKAGE_VERSION}] Fetch completed with status:`, response.status, response.statusText);
+            // Log all headers
+            console.log(`[callAI:${PACKAGE_VERSION}] Response headers:`);
+            response.headers.forEach((value, name) => {
+                console.log(`[callAI:${PACKAGE_VERSION}]   ${name}: ${value}`);
+            });
+            // Clone response for diagnostic purposes only
+            const diagnosticResponse = response.clone();
+            try {
+                // Try to get the response as text for debugging
+                const responseText = await diagnosticResponse.text();
+                console.log(`[callAI:${PACKAGE_VERSION}] First 500 chars of response body:`, responseText.substring(0, 500) + (responseText.length > 500 ? '...' : ''));
+            }
+            catch (e) {
+                console.log(`[callAI:${PACKAGE_VERSION}] Could not read response body for diagnostics:`, e);
+            }
         }
         catch (fetchError) {
             console.error(`[callAI:${PACKAGE_VERSION}] Network error during fetch:`, fetchError);
@@ -47,63 +63,84 @@ function callAI(prompt, options = {}) {
         // Explicitly check for HTTP error status and log extensively
         console.log(`[callAI:${PACKAGE_VERSION}] Response.ok =`, response.ok);
         console.log(`[callAI:${PACKAGE_VERSION}] Response.status =`, response.status);
-        // Enhanced error handling with more debugging - MUST check !response.ok
-        if (!response.ok) {
-            console.log(`[callAI:${PACKAGE_VERSION}] Detected error response with status:`, response.status);
-            if (options.debug) {
-                console.error(`[callAI:${PACKAGE_VERSION}] HTTP Error:`, response.status, response.statusText, response.url);
-            }
-            // Check if this is an invalid model error
-            console.log(`[callAI:${PACKAGE_VERSION}] Checking for invalid model error...`);
-            let isInvalidModel = false;
-            let errorData = null;
-            try {
-                const result = await checkForInvalidModelError(response.clone(), // Clone response since we'll need to read body twice
-                model, false, options.skipRetry);
-                isInvalidModel = result.isInvalidModel;
-                errorData = result.errorData;
-                console.log(`[callAI:${PACKAGE_VERSION}] Invalid model check result:`, isInvalidModel);
-            }
-            catch (checkError) {
-                console.error(`[callAI:${PACKAGE_VERSION}] Error during invalid model check:`, checkError);
-            }
-            if (isInvalidModel && !options.skipRetry) {
-                if (options.debug) {
-                    console.log(`[callAI:${PACKAGE_VERSION}] Retrying with fallback model: ${FALLBACK_MODEL}`);
+        console.log(`[callAI:${PACKAGE_VERSION}] Response.statusText =`, response.statusText);
+        console.log(`[callAI:${PACKAGE_VERSION}] Response.type =`, response.type);
+        // Double check for content-type to see if there's a mismatch in error response handling
+        const contentType = response.headers.get('content-type') || '';
+        console.log(`[callAI:${PACKAGE_VERSION}] Content-Type =`, contentType);
+        // Browser-compatible error handling - must check BOTH status code AND content-type
+        // Some browsers will report status 200 for SSE streams even when server returns 400
+        const hasHttpError = !response.ok || response.status >= 400;
+        const hasJsonError = contentType.includes('application/json');
+        if (hasHttpError || hasJsonError) {
+            console.log(`[callAI:${PACKAGE_VERSION}] ⚠️ Error detected - HTTP Status: ${response.status}, Content-Type: ${contentType}`);
+            // Handle the error with fallback model if appropriate
+            if (!options.skipRetry) {
+                const clonedResponse = response.clone();
+                let isInvalidModel = false;
+                try {
+                    // Check if this is an invalid model error
+                    const modelCheckResult = await checkForInvalidModelError(clonedResponse, model, false, options.skipRetry);
+                    isInvalidModel = modelCheckResult.isInvalidModel;
+                    if (isInvalidModel) {
+                        if (options.debug) {
+                            console.log(`[callAI:${PACKAGE_VERSION}] Retrying with fallback model: ${FALLBACK_MODEL}`);
+                        }
+                        // Retry with fallback model
+                        return await callAI(prompt, { ...options, model: FALLBACK_MODEL });
+                    }
+                }
+                catch (modelCheckError) {
+                    console.error(`[callAI:${PACKAGE_VERSION}] Error during model check:`, modelCheckError);
+                    // Continue with normal error handling
                 }
-                // Retry with fallback model - it will return a promise
-                const result = await callAI(prompt, { ...options, model: FALLBACK_MODEL });
-                return result;
             }
-            // Get full error text from body
-            console.log(`[callAI:${PACKAGE_VERSION}] Reading error response body...`);
-            let errorText = "";
+            // Extract error details from response
             try {
-                errorText = await response.text();
-                console.log(`[callAI:${PACKAGE_VERSION}] Error response body:`, errorText);
+                // Try to get error details from the response body
+                const errorBody = await response.text();
+                console.log(`[callAI:${PACKAGE_VERSION}] Error body:`, errorBody);
+                try {
+                    // Try to parse JSON error
+                    const errorJson = JSON.parse(errorBody);
+                    console.log(`[callAI:${PACKAGE_VERSION}] Parsed error:`, errorJson);
+                    // Extract message from OpenRouter error format
+                    const errorMessage = ((errorJson.error && typeof errorJson.error === 'object') ?
+                        errorJson.error.message :
+                        errorJson.error || errorJson.message ||
+                            `API returned ${response.status}: ${response.statusText}`);
+                    // Create error with standard format
+                    const error = new Error(errorMessage);
+                    // Add useful metadata
+                    error.status = response.status;
+                    error.statusText = response.statusText;
+                    error.details = errorJson;
+                    error.contentType = contentType;
+                    throw error;
+                }
+                catch (jsonError) {
+                    // If JSON parsing fails, throw a simpler error
+                    console.log(`[callAI:${PACKAGE_VERSION}] JSON parse error:`, jsonError);
+                    const error = new Error(`API error: ${response.status} ${response.statusText}`);
+                    error.status = response.status;
+                    error.statusText = response.statusText;
+                    error.details = errorBody;
+                    error.contentType = contentType;
+                    throw error;
+                }
             }
-            catch (error) {
-                const textError = error;
-                console.error(`[callAI:${PACKAGE_VERSION}] Error reading response body:`, textError);
-                errorText = `Failed to read error details: ${textError.message || 'Unknown error'}`;
+            catch (responseError) {
+                if (responseError instanceof Error) {
+                    // Re-throw if it's already properly formatted
+                    throw responseError;
+                }
+                // Fallback error
+                const error = new Error(`API returned ${response.status}: ${response.statusText}`);
+                error.status = response.status;
+                error.statusText = response.statusText;
+                error.contentType = contentType;
+                throw error;
             }
-            // Create a detailed error with status information
-            console.log(`[callAI:${PACKAGE_VERSION}] Creating error object with status ${response.status}`);
-            const errorMessage = `API returned error ${response.status}: ${response.statusText}`;
-            const error = new Error(errorMessage);
-            // Add extra properties for more context
-            error.status = response.status;
-            error.statusText = response.statusText;
-            error.details = errorText;
-            // Ensure this error is thrown and caught properly in the Promise chain
-            console.error(`[callAI:${PACKAGE_VERSION}] THROWING API ERROR:`, {
-                message: errorMessage,
-                status: response.status,
-                statusText: response.statusText,
-                details: errorText
-            });
-            // This MUST throw the error from the promise
-            return Promise.reject(error);
         }
         // Only if response is OK, create and return the streaming generator
         console.log(`[callAI:${PACKAGE_VERSION}] Response OK, creating streaming generator`);
@@ -345,7 +382,7 @@ async function callAINonStreaming(prompt, options = {}, isRetry = false) {
         const { endpoint, requestOptions, model, schemaStrategy } = prepareRequestParams(prompt, options);
         const response = await fetch(endpoint, requestOptions);
         // Handle HTTP errors, with potential fallback for invalid model
-        if (!response.ok) {
+        if (!response.ok || response.status >= 400) {
             const { isInvalidModel } = await checkForInvalidModelError(response, model, isRetry, options.skipRetry);
             if (isInvalidModel) {
                 // Retry with fallback model
@@ -468,6 +505,10 @@ async function extractClaudeResponse(response) {
  * return a 200 OK initially but then deliver error information in the stream.
  */
 async function* createStreamingGenerator(response, options, schemaStrategy, model) {
+    console.log(`[callAI:${PACKAGE_VERSION}] Starting streaming generator with model: ${model}`);
+    console.log(`[callAI:${PACKAGE_VERSION}] Response status:`, response.status);
+    console.log(`[callAI:${PACKAGE_VERSION}] Response type:`, response.type);
+    console.log(`[callAI:${PACKAGE_VERSION}] Response Content-Type:`, response.headers.get('content-type'));
     try {
         // Handle streaming response
         if (!response.body) {
@@ -481,16 +522,26 @@ async function* createStreamingGenerator(response, options, schemaStrategy, mode
         while (true) {
             const { done, value } = await reader.read();
             if (done) {
+                console.log(`[callAI:${PACKAGE_VERSION}] Stream done=true after ${chunkCount} chunks`);
                 if (options.debug) {
                     console.log(`[callAI-streaming:complete v${PACKAGE_VERSION}] Stream finished after ${chunkCount} chunks`);
                 }
                 break;
             }
+            // Increment chunk counter before processing
+            chunkCount++;
             const chunk = decoder.decode(value);
+            console.log(`[callAI:${PACKAGE_VERSION}] Raw chunk #${chunkCount} (${chunk.length} bytes):`, chunk.length > 200 ? chunk.substring(0, 200) + '...' : chunk);
             const lines = chunk.split("\n").filter((line) => line.trim() !== "");
+            console.log(`[callAI:${PACKAGE_VERSION}] Chunk #${chunkCount} contains ${lines.length} non-empty lines`);
             for (const line of lines) {
+                console.log(`[callAI:${PACKAGE_VERSION}] Processing line:`, line.length > 100 ? line.substring(0, 100) + '...' : line);
                 if (line.startsWith("data: ")) {
-                    // Simple debug logging of raw SSE events with no processing
+                    let data = line.slice(6);
+                    if (data === "[DONE]") {
+                        console.log(`[callAI:${PACKAGE_VERSION}] Received [DONE] marker`);
+                        break;
+                    }
                     if (options.debug) {
                         console.log(`[callAI:raw] ${line}`);
                     }
@@ -502,11 +553,23 @@ async function* createStreamingGenerator(response, options, schemaStrategy, mode
                     try {
                         const jsonLine = line.replace("data: ", "");
                         if (!jsonLine.trim()) {
+                            console.log(`[callAI:${PACKAGE_VERSION}] Empty JSON line after data: prefix`);
                             continue;
                         }
-                        chunkCount++;
+                        console.log(`[callAI:${PACKAGE_VERSION}] JSON line (first 100 chars):`, jsonLine.length > 100 ? jsonLine.substring(0, 100) + '...' : jsonLine);
                         // Parse the JSON chunk
-                        const json = JSON.parse(jsonLine);
+                        let json;
+                        try {
+                            json = JSON.parse(jsonLine);
+                            console.log(`[callAI:${PACKAGE_VERSION}] Parsed JSON:`, JSON.stringify(json).length > 100 ?
+                                JSON.stringify(json).substring(0, 100) + '...' :
+                                JSON.stringify(json));
+                        }
+                        catch (parseError) {
+                            console.error(`[callAI:${PACKAGE_VERSION}] JSON parse error:`, parseError);
+                            console.error(`[callAI:${PACKAGE_VERSION}] Failed to parse:`, jsonLine);
+                            continue;
+                        }
                         // Enhanced error detection - check for BOTH error and json.error
                         // Some APIs return 200 OK but then deliver errors in the stream
                         if (json.error || (typeof json === 'object' && 'error' in json)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "call-ai",
-  "version": "0.7.0-dev-preview-9",
+  "version": "0.7.0-dev-preview-12",
   "description": "Lightweight library for making AI API calls with streaming support",
   "main": "dist/index.js",
   "browser": "dist/index.js",