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

package/dist/api.d.ts

@@ -7,6 +7,7 @@ import { CallAIOptions, Message, StreamResponse } from "./types";
  * @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 | 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
@@ -27,19 +28,45 @@ function callAI(prompt, options = {}) {
         return callAINonStreaming(prompt, options);
     }
     // Handle streaming mode - return a Promise that resolves to an AsyncGenerator
-    return (async () => {
+    // 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
+        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}`);
@@ -49,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
@@ -61,14 +96,28 @@ 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
+    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
@@ -96,6 +145,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
  */

package/dist/types.d.ts

@@ -68,6 +68,12 @@ export interface SchemaStrategy {
  * 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-6",
+  "version": "0.7.0-dev-preview-8",
   "description": "Lightweight library for making AI API calls with streaming support",
   "main": "dist/index.js",
   "browser": "dist/index.js",