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

package/dist/api.js

@@ -33,15 +33,40 @@ function callAI(prompt, options = {}) {
         // Do setup and validation before returning the generator
         const { endpoint, requestOptions, model, schemaStrategy } = prepareRequestParams(prompt, { ...options, stream: true });
         // Make the fetch request and handle errors before creating the generator
-        const response = await fetch(endpoint, requestOptions);
-        // Enhanced error handling with more debugging
+        console.log(`[callAI:${PACKAGE_VERSION}] Making fetch request to: ${endpoint}`);
+        console.log(`[callAI:${PACKAGE_VERSION}] With model: ${model}`);
+        let response;
+        try {
+            response = await fetch(endpoint, requestOptions);
+            console.log(`[callAI:${PACKAGE_VERSION}] Fetch completed with status:`, response.status, response.statusText);
+        }
+        catch (fetchError) {
+            console.error(`[callAI:${PACKAGE_VERSION}] Network error during fetch:`, fetchError);
+            throw fetchError; // Re-throw network errors
+        }
+        // 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
-            const { isInvalidModel, errorData } = await checkForInvalidModelError(response.clone(), // Clone response since we'll need to read body twice
-            model, false, options.skipRetry);
+            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}`);
@@ -51,11 +76,19 @@ function callAI(prompt, options = {}) {
                 return result;
             }
             // Get full error text from body
-            const errorText = await response.text();
-            if (options.debug) {
-                console.error(`[callAI:${PACKAGE_VERSION}] Error response body:`, errorText);
+            console.log(`[callAI:${PACKAGE_VERSION}] Reading error response body...`);
+            let errorText = "";
+            try {
+                errorText = await response.text();
+                console.log(`[callAI:${PACKAGE_VERSION}] Error response body:`, errorText);
+            }
+            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'}`;
             }
             // 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
@@ -63,12 +96,17 @@ function callAI(prompt, options = {}) {
             error.statusText = response.statusText;
             error.details = errorText;
             // Ensure this error is thrown and caught properly in the Promise chain
-            if (options.debug) {
-                console.error(`[callAI:${PACKAGE_VERSION}] Throwing error:`, error);
-            }
-            throw error;
+            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`);
         return createStreamingGenerator(response, options, schemaStrategy, model);
     })();
     // For backward compatibility with v0.6.x where users didn't await the result
@@ -424,6 +462,10 @@ async function extractClaudeResponse(response) {
 /**
  * Generator factory function for streaming API calls
  * This is called after the fetch is made and response is validated
+ *
+ * Note: Even though we checked response.ok before creating this generator,
+ * we need to be prepared for errors that may occur during streaming. Some APIs
+ * return a 200 OK initially but then deliver error information in the stream.
  */
 async function* createStreamingGenerator(response, options, schemaStrategy, model) {
     try {
@@ -465,12 +507,21 @@ async function* createStreamingGenerator(response, options, schemaStrategy, mode
                         chunkCount++;
                         // Parse the JSON chunk
                         const json = JSON.parse(jsonLine);
-                        // Check for error in the parsed JSON response
-                        if (json.error) {
-                            // Use the standard error format as the rest of the library
-                            // We need to throw the error properly
-                            handleApiError(new Error(`API returned error: ${JSON.stringify(json.error)}`), "Streaming API call error", options.debug);
-                            // This code is unreachable as handleApiError throws
+                        // 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)) {
+                            console.error(`[callAI:${PACKAGE_VERSION}] Detected error in streaming response:`, json);
+                            // Create a detailed error object similar to our HTTP error handling
+                            const errorMessage = json.error?.message ||
+                                json.error?.toString() ||
+                                JSON.stringify(json.error || json);
+                            const detailedError = new Error(`API streaming error: ${errorMessage}`);
+                            // Add error metadata
+                            detailedError.status = json.error?.status || 400;
+                            detailedError.statusText = json.error?.type || 'Bad Request';
+                            detailedError.details = JSON.stringify(json.error || json);
+                            console.error(`[callAI:${PACKAGE_VERSION}] Throwing stream error:`, detailedError);
+                            throw detailedError;
                         }
                         // Handle tool use response - Claude with schema cases
                         const isClaudeWithSchema = /claude/i.test(model) && schemaStrategy.strategy === "tool_mode";

package/package.json

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