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

package/dist/api.d.ts

@@ -1,12 +1,13 @@
 /**
  * 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
  * @param options Configuration options including optional schema for structured output
  * @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
+ *          or a Promise that resolves to an AsyncGenerator when streaming is enabled.
+ *          The AsyncGenerator yields partial responses as they arrive.
  */
-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

@@ -12,7 +12,8 @@ const FALLBACK_MODEL = "openrouter/auto";
  * @param prompt User prompt as string or an array of message objects
  * @param options Configuration options including optional schema for structured output
  * @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
+ *          or a Promise that resolves to an AsyncGenerator when streaming is enabled.
+ *          The AsyncGenerator yields partial responses as they arrive.
  */
 function callAI(prompt, options = {}) {
     // Check if we need to force streaming based on model strategy
@@ -26,8 +27,59 @@ 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
+    // but also supports legacy non-awaited usage for backward compatibility
+    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
+        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);
+    })();
+    // 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.`);
+    }
+    // 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
+    return createBackwardCompatStreamingProxy(streamPromise);
 }
 /**
  * Buffer streaming results into a single response for cases where
@@ -41,7 +93,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;
@@ -55,6 +107,51 @@ async function bufferStreamingResults(prompt, options) {
         handleApiError(error, "Streaming buffer error", options.debug);
     }
 }
+/**
+ * Standardized API error handler
+ */
+/**
+ * Create a proxy that acts both as a Promise and an AsyncGenerator for backward compatibility
+ * @internal This is for internal use only, not part of public API
+ */
+function createBackwardCompatStreamingProxy(promise) {
+    // Create a proxy that forwards methods to the Promise or AsyncGenerator as appropriate
+    return new Proxy({}, {
+        get(target, prop) {
+            // First check if it's an AsyncGenerator method (needed for for-await)
+            if (prop === 'next' || prop === 'throw' || prop === 'return' || prop === Symbol.asyncIterator) {
+                // Create wrapper functions that await the Promise first
+                if (prop === Symbol.asyncIterator) {
+                    return function () {
+                        return {
+                            // Implement async iterator that gets the generator first
+                            async next(value) {
+                                try {
+                                    const generator = await promise;
+                                    return generator.next(value);
+                                }
+                                catch (error) {
+                                    // Turn Promise rejection into iterator result with error thrown
+                                    return Promise.reject(error);
+                                }
+                            }
+                        };
+                    };
+                }
+                // Methods like next, throw, return
+                return async function (value) {
+                    const generator = await promise;
+                    return generator[prop](value);
+                };
+            }
+            // Then check if it's a Promise method
+            if (prop === 'then' || prop === 'catch' || prop === 'finally') {
+                return promise[prop].bind(promise);
+            }
+            return undefined;
+        }
+    });
+}
 /**
  * Standardized API error handler
  */
@@ -68,27 +165,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
+            });
+        }
+        // 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: false, errorData };
+        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 +422,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,16 @@ export interface SchemaStrategy {
     processResponse: ModelStrategy["processResponse"];
     shouldForceStream: boolean;
 }
+/**
+ * Return type for streaming API calls
+ */
+export type StreamResponse = AsyncGenerator<string, string, unknown>;
+/**
+ * @internal
+ * Internal type for backward compatibility with v0.6.x
+ * This type is not exposed in public API documentation
+ */
+export type ThenableStreamResponse = AsyncGenerator<string, string, unknown> & Promise<StreamResponse>;
 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-7",
   "description": "Lightweight library for making AI API calls with streaming support",
   "main": "dist/index.js",
   "browser": "dist/index.js",