call-ai 0.7.0 → 0.7.2

package/dist/api.js

@@ -32,7 +32,6 @@ function callAI(prompt, options = {}) {
     const streamPromise = (async () => {
         // 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
         if (options.debug) {
             console.log(`[callAI:${PACKAGE_VERSION}] Making fetch request to: ${endpoint}`);
             console.log(`[callAI:${PACKAGE_VERSION}] With model: ${model}`);
@@ -62,7 +61,9 @@ function callAI(prompt, options = {}) {
             }
         }
         catch (fetchError) {
-            console.error(`[callAI:${PACKAGE_VERSION}] Network error during fetch:`, fetchError);
+            if (options.debug) {
+                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 if debug is enabled
@@ -89,7 +90,7 @@ function callAI(prompt, options = {}) {
                 let isInvalidModel = false;
                 try {
                     // Check if this is an invalid model error
-                    const modelCheckResult = await checkForInvalidModelError(clonedResponse, model, false, options.skipRetry);
+                    const modelCheckResult = await checkForInvalidModelError(clonedResponse, model, false, options.skipRetry, options.debug);
                     isInvalidModel = modelCheckResult.isInvalidModel;
                     if (isInvalidModel) {
                         if (options.debug) {
@@ -211,9 +212,9 @@ function callAI(prompt, options = {}) {
     })();
     // For backward compatibility with v0.6.x where users didn't await the result
     if (process.env.NODE_ENV !== "production") {
-        console.warn(`[callAI:${PACKAGE_VERSION}] WARNING: Using callAI with streaming without await is deprecated. ` +
-            `Please use 'const generator = await callAI(...)' instead of 'const generator = callAI(...)'. ` +
-            `This backward compatibility will be removed in a future version.`);
+        if (options.debug) {
+            console.warn(`[callAI:${PACKAGE_VERSION}] No await found - using legacy streaming pattern. This will be removed in a future version and may cause issues with certain models.`);
+        }
     }
     // Create a proxy object that acts both as a Promise and an AsyncGenerator for backward compatibility
     // @ts-ignore - We're deliberately implementing a proxy with dual behavior
@@ -305,7 +306,7 @@ function handleApiError(error, context, debug = false) {
 /**
  * Helper to check if an error indicates invalid model and handle fallback
  */
-async function checkForInvalidModelError(response, model, isRetry, skipRetry = false) {
+async function checkForInvalidModelError(response, model, isRetry, skipRetry = false, debug = false) {
     // Skip retry immediately if skipRetry is true or if we're already retrying
     if (skipRetry || isRetry) {
         return { isInvalidModel: false };
@@ -318,8 +319,7 @@ async function checkForInvalidModelError(response, model, isRetry, skipRetry = f
     const clonedResponse = response.clone();
     try {
         const errorData = await clonedResponse.json();
-        const debugEnabled = true; // Always log for now to help diagnose the issue
-        if (debugEnabled) {
+        if (debug) {
             console.log(`[callAI:${PACKAGE_VERSION}] Checking for invalid model error:`, {
                 model,
                 statusCode: response.status,
@@ -349,29 +349,37 @@ async function checkForInvalidModelError(response, model, isRetry, skipRetry = f
         }
         // Test the error message against each pattern
         const isInvalidModel = invalidModelPatterns.some((pattern) => errorMessage.includes(pattern.toLowerCase()));
-        if (isInvalidModel && debugEnabled) {
+        if (isInvalidModel && debug) {
             console.warn(`[callAI:${PACKAGE_VERSION}] Model ${model} not valid, will retry with ${FALLBACK_MODEL}`);
         }
         return { isInvalidModel, errorData };
     }
     catch (parseError) {
         // If we can't parse the response as JSON, try to read it as text
-        console.error("Failed to parse error response as JSON:", parseError);
+        if (debug) {
+            console.error("Failed to parse error response as JSON:", parseError);
+        }
         try {
             const textResponse = await response.clone().text();
-            console.log("Error response as text:", textResponse);
+            if (debug) {
+                console.log("Error response as text:", textResponse);
+            }
             // Even if it's not JSON, check if it contains any of our known patterns
             const lowerText = textResponse.toLowerCase();
             const isInvalidModel = lowerText.includes("invalid model") ||
                 lowerText.includes("not exist") ||
                 lowerText.includes("fake-model");
             if (isInvalidModel) {
-                console.warn(`[callAI:${PACKAGE_VERSION}] Detected invalid model in text response for ${model}`);
+                if (debug) {
+                    console.warn(`[callAI:${PACKAGE_VERSION}] Detected invalid model in text response for ${model}`);
+                }
             }
             return { isInvalidModel, errorData: { text: textResponse } };
         }
         catch (textError) {
-            console.error("Failed to read error response as text:", textError);
+            if (debug) {
+                console.error("Failed to read error response as text:", textError);
+            }
             return { isInvalidModel: false };
         }
     }
@@ -449,7 +457,7 @@ async function callAINonStreaming(prompt, options = {}, isRetry = false) {
         const response = await fetch(endpoint, requestOptions);
         // Handle HTTP errors, with potential fallback for invalid model
         if (!response.ok || response.status >= 400) {
-            const { isInvalidModel } = await checkForInvalidModelError(response, model, isRetry, options.skipRetry);
+            const { isInvalidModel } = await checkForInvalidModelError(response, model, isRetry, options.skipRetry, options.debug);
             if (isInvalidModel) {
                 // Retry with fallback model
                 return callAINonStreaming(prompt, { ...options, model: FALLBACK_MODEL }, true);
@@ -475,13 +483,17 @@ async function callAINonStreaming(prompt, options = {}, isRetry = false) {
         }
         // Handle error responses
         if (result.error) {
-            console.error("API returned an error:", result.error);
+            if (options.debug) {
+                console.error("API returned an error:", result.error);
+            }
             // If it's a model error and not already a retry, try with fallback
             if (!isRetry &&
                 !options.skipRetry &&
                 result.error.message &&
                 result.error.message.toLowerCase().includes("not a valid model")) {
-                console.warn(`Model ${model} error, retrying with ${FALLBACK_MODEL}`);
+                if (options.debug) {
+                    console.warn(`Model ${model} error, retrying with ${FALLBACK_MODEL}`);
+                }
                 return callAINonStreaming(prompt, { ...options, model: FALLBACK_MODEL }, true);
             }
             return JSON.stringify({
@@ -551,6 +563,7 @@ async function extractClaudeResponse(response) {
         ]));
     }
     catch (textError) {
+        // Always log timeout errors
         console.error(`Text extraction timed out or failed:`, textError);
         throw new Error("Claude response text extraction timed out. This is likely an issue with the Claude API's response format.");
     }
@@ -558,6 +571,7 @@ async function extractClaudeResponse(response) {
         return JSON.parse(textResponse);
     }
     catch (err) {
+        // Always log JSON parsing errors
         console.error(`Failed to parse Claude response as JSON:`, err);
         throw new Error(`Failed to parse Claude response as JSON: ${err}`);
     }
@@ -629,29 +643,36 @@ 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`);
+                            if (options.debug) {
+                                console.log(`[callAI:${PACKAGE_VERSION}] Empty JSON line after data: prefix`);
+                            }
                             continue;
                         }
-                        console.log(`[callAI:${PACKAGE_VERSION}] JSON line (first 100 chars):`, jsonLine.length > 100
-                            ? jsonLine.substring(0, 100) + "..."
-                            : jsonLine);
+                        if (options.debug) {
+                            console.log(`[callAI:${PACKAGE_VERSION}] JSON line (first 100 chars):`, jsonLine.length > 100
+                                ? jsonLine.substring(0, 100) + "..."
+                                : jsonLine);
+                        }
                         // Parse the JSON chunk
                         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));
+                            if (options.debug) {
+                                console.log(`[callAI:${PACKAGE_VERSION}] Parsed JSON:`, JSON.stringify(json).substring(0, 1000));
+                            }
                         }
                         catch (parseError) {
-                            console.error(`[callAI:${PACKAGE_VERSION}] JSON parse error:`, parseError);
-                            console.error(`[callAI:${PACKAGE_VERSION}] Failed to parse:`, jsonLine);
+                            if (options.debug) {
+                                console.error(`[callAI:${PACKAGE_VERSION}] JSON parse error:`, parseError);
+                            }
                             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);
+                            if (options.debug) {
+                                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() ||
@@ -766,7 +787,9 @@ async function* createStreamingGenerator(response, options, schemaStrategy, mode
                         }
                     }
                     catch (e) {
-                        console.error(`[callAIStreaming] Error parsing JSON chunk:`, e);
+                        if (options.debug) {
+                            console.error(`[callAIStreaming] Error parsing JSON chunk:`, e);
+                        }
                     }
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "call-ai",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "Lightweight library for making AI API calls with streaming support",
   "main": "dist/index.js",
   "browser": "dist/index.js",
@@ -16,6 +16,17 @@
   "bugs": {
     "url": "https://github.com/fireproof-storage/call-ai/issues"
   },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --testPathIgnorePatterns=\".*\\.integration\\.(no-await\\.)?test\\.ts$\"",
+    "test:integration": "jest --testMatch=\"**/*\\.integration\\.test\\.ts\"",
+    "test:all": "jest",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "coverage": "jest --coverage",
+    "check": "npm run typecheck && npm run format && npm run test"
+  },
   "keywords": [
     "ai",
     "llm",
@@ -40,15 +51,5 @@
   },
   "engines": {
     "node": ">=14.0.0"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "jest --testPathIgnorePatterns=\".*\\.integration\\.(no-await\\.)?test\\.ts$\"",
-    "test:integration": "jest --testMatch=\"**/*\\.integration\\.test\\.ts\"",
-    "test:all": "jest",
-    "typecheck": "tsc --noEmit",
-    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
-    "coverage": "jest --coverage",
-    "check": "npm run typecheck && npm run format && npm run test"
   }
-}
+}