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

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,7 +28,8 @@ 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
@@ -69,6 +71,15 @@ function callAI(prompt, options = {}) {
         // 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
@@ -96,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
  */

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-7",
   "description": "Lightweight library for making AI API calls with streaming support",
   "main": "dist/index.js",
   "browser": "dist/index.js",