call-ai 0.7.0-dev-preview-8 → 0.7.0-dev-preview-10

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,6 +63,7 @@ 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);
+        console.log(`[callAI:${PACKAGE_VERSION}] Response.type =`, response.type);
         // 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);
@@ -462,8 +479,16 @@ 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) {
+    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) {
@@ -477,16 +502,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}`);
                     }
@@ -498,17 +533,38 @@ 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);
-                        // 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
+                        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)) {
+                            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-8",
+  "version": "0.7.0-dev-preview-10",
   "description": "Lightweight library for making AI API calls with streaming support",
   "main": "dist/index.js",
   "browser": "dist/index.js",