call-ai 0.7.0-dev-preview-5 → 0.7.0-dev-preview-6

package/dist/api.d.ts

@@ -1,7 +1,7 @@
 /**
  * Core API implementation for call-ai
  */
-import { CallAIOptions, Message } from "./types";
+import { CallAIOptions, Message, StreamResponse } from "./types";
 /**
  * Make an AI API call with the given options
  * @param prompt User prompt as string or an array of message objects
@@ -9,4 +9,4 @@ import { CallAIOptions, Message } from "./types";
  * @returns A Promise that resolves to the complete response string when streaming is disabled,
  *          or an AsyncGenerator that yields partial responses when streaming is enabled
  */
-export declare function callAI(prompt: string | Message[], options?: CallAIOptions): Promise<string> | AsyncGenerator<string, string | undefined, unknown>;
+export declare function callAI(prompt: string | Message[], options?: CallAIOptions): Promise<string | StreamResponse>;

package/dist/api.js

@@ -26,8 +26,49 @@ function callAI(prompt, options = {}) {
     if (options.stream !== true) {
         return callAINonStreaming(prompt, options);
     }
-    // Handle streaming mode
-    return callAIStreaming(prompt, options);
+    // Handle streaming mode - return a Promise that resolves to an AsyncGenerator
+    return (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
+        const response = await fetch(endpoint, requestOptions);
+        // Enhanced error handling with more debugging
+        if (!response.ok) {
+            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);
+            if (isInvalidModel && !options.skipRetry) {
+                if (options.debug) {
+                    console.log(`[callAI:${PACKAGE_VERSION}] Retrying with fallback model: ${FALLBACK_MODEL}`);
+                }
+                // 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
+            const errorText = await response.text();
+            if (options.debug) {
+                console.error(`[callAI:${PACKAGE_VERSION}] Error response body:`, errorText);
+            }
+            // Create a detailed error with status information
+            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
+            if (options.debug) {
+                console.error(`[callAI:${PACKAGE_VERSION}] Throwing error:`, error);
+            }
+            throw error;
+        }
+        // Only if response is OK, create and return the streaming generator
+        return createStreamingGenerator(response, options, schemaStrategy, model);
+    })();
 }
 /**
  * Buffer streaming results into a single response for cases where
@@ -41,7 +82,7 @@ async function bufferStreamingResults(prompt, options) {
     };
     try {
         // Get streaming generator
-        const generator = callAIStreaming(prompt, streamingOptions);
+        const generator = await callAI(prompt, streamingOptions);
         // Buffer all chunks
         let finalResult = "";
         let chunkCount = 0;
@@ -68,27 +109,74 @@ 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) {
-    // Skip retry immediately if skipRetry is true
-    if (skipRetry || response.status !== 400 || isRetry) {
+    // Skip retry immediately if skipRetry is true or if we're already retrying
+    if (skipRetry || isRetry) {
+        return { isInvalidModel: false };
+    }
+    // We want to check all 4xx errors, not just 400
+    if (response.status < 400 || response.status >= 500) {
         return { isInvalidModel: false };
     }
     // Clone the response so we can read the body
     const clonedResponse = response.clone();
     try {
         const errorData = await clonedResponse.json();
-        // Check if the error message indicates an invalid model
-        if (errorData.error &&
-            errorData.error.message &&
-            errorData.error.message.toLowerCase().includes("not a valid model")) {
-            console.warn(`Model ${model} not valid, retrying with ${FALLBACK_MODEL}`);
-            return { isInvalidModel: true };
+        const debugEnabled = true; // Always log for now to help diagnose the issue
+        if (debugEnabled) {
+            console.log(`[callAI:${PACKAGE_VERSION}] Checking for invalid model error:`, {
+                model,
+                statusCode: response.status,
+                errorData
+            });
         }
-        return { isInvalidModel: false, errorData };
+        // Common patterns for invalid model errors across different providers
+        const invalidModelPatterns = [
+            "not a valid model",
+            "model .* does not exist",
+            "invalid model",
+            "unknown model",
+            "no provider was found",
+            "fake-model", // For our test case
+            "does-not-exist" // For our test case
+        ];
+        // Check if error message contains any of our patterns
+        let errorMessage = '';
+        if (errorData.error && errorData.error.message) {
+            errorMessage = errorData.error.message.toLowerCase();
+        }
+        else if (errorData.message) {
+            errorMessage = errorData.message.toLowerCase();
+        }
+        else {
+            errorMessage = JSON.stringify(errorData).toLowerCase();
+        }
+        // Test the error message against each pattern
+        const isInvalidModel = invalidModelPatterns.some(pattern => errorMessage.includes(pattern.toLowerCase()));
+        if (isInvalidModel && debugEnabled) {
+            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, continue with original error
-        console.error("Failed to parse error response:", parseError);
-        return { isInvalidModel: false };
+        // 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);
+        try {
+            const textResponse = await response.clone().text();
+            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}`);
+            }
+            return { isInvalidModel, errorData: { text: textResponse } };
+        }
+        catch (textError) {
+            console.error("Failed to read error response as text:", textError);
+            return { isInvalidModel: false };
+        }
     }
 }
 /**
@@ -278,30 +366,11 @@ async function extractClaudeResponse(response) {
     }
 }
 /**
- * Internal implementation for streaming API calls
+ * Generator factory function for streaming API calls
+ * This is called after the fetch is made and response is validated
  */
-async function* callAIStreaming(prompt, options = {}, isRetry = false) {
+async function* createStreamingGenerator(response, options, schemaStrategy, model) {
     try {
-        const { endpoint, requestOptions, model, schemaStrategy } = prepareRequestParams(prompt, { ...options, stream: true });
-        const response = await fetch(endpoint, requestOptions);
-        if (!response.ok) {
-            const { isInvalidModel } = await checkForInvalidModelError(response, model, isRetry, options.skipRetry);
-            if (isInvalidModel) {
-                // Retry with fallback model
-                return yield* callAIStreaming(prompt, { ...options, model: FALLBACK_MODEL }, true);
-            }
-            const errorText = await response.text();
-            console.error(`API Error: ${response.status} ${response.statusText}`, errorText);
-            // Create a detailed error with status information
-            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;
-            // Throw immediately - we want this to propagate correctly in all environments
-            throw error;
-        }
         // Handle streaming response
         if (!response.body) {
             throw new Error("Response body is undefined - API endpoint may not support streaming");

package/dist/types.d.ts

@@ -64,6 +64,10 @@ export interface SchemaStrategy {
     processResponse: ModelStrategy["processResponse"];
     shouldForceStream: boolean;
 }
+/**
+ * Return type for streaming API calls
+ */
+export type StreamResponse = AsyncGenerator<string, string, unknown>;
 export interface CallAIOptions {
     /**
      * API key for authentication

package/package.json

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