call-ai 0.6.0 → 0.6.2

package/dist/api.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callAI = callAI;
 const strategies_1 = require("./strategies");
+// Default fallback model when the primary model fails or is unavailable
+const FALLBACK_MODEL = "openrouter/auto";
 /**
  * Make an AI API call with the given options
  * @param prompt User prompt as string or an array of message objects
@@ -60,6 +62,33 @@ function handleApiError(error, context) {
         message: `Sorry, I couldn't process that request: ${String(error)}`,
     });
 }
+/**
+ * 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) {
+        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 };
+        }
+        return { isInvalidModel: false, 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 };
+    }
+}
 /**
  * Prepare request parameters common to both streaming and non-streaming calls
  */
@@ -110,6 +139,8 @@ function prepareRequestParams(prompt, options) {
         method: "POST",
         headers: {
             Authorization: `Bearer ${apiKey}`,
+            "HTTP-Referer": "https://vibes.diy",
+            "X-Title": "Vibes",
             "Content-Type": "application/json",
         },
         body: JSON.stringify(requestParams),
@@ -119,10 +150,19 @@ function prepareRequestParams(prompt, options) {
 /**
  * Internal implementation for non-streaming API calls
  */
-async function callAINonStreaming(prompt, options = {}) {
+async function callAINonStreaming(prompt, options = {}, isRetry = false) {
     try {
         const { endpoint, requestOptions, model, schemaStrategy } = prepareRequestParams(prompt, options);
         const response = await fetch(endpoint, requestOptions);
+        // Handle HTTP errors, with potential fallback for invalid model
+        if (!response.ok) {
+            const { isInvalidModel } = await checkForInvalidModelError(response, model, isRetry, options.skipRetry);
+            if (isInvalidModel) {
+                // Retry with fallback model
+                return callAINonStreaming(prompt, { ...options, model: FALLBACK_MODEL }, true);
+            }
+            throw new Error(`HTTP error! Status: ${response.status}`);
+        }
         let result;
         // For Claude, use text() instead of json() to avoid potential hanging
         if (/claude/i.test(model)) {
@@ -139,6 +179,14 @@ async function callAINonStreaming(prompt, options = {}) {
         // Handle error responses
         if (result.error) {
             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}`);
+                return callAINonStreaming(prompt, { ...options, model: FALLBACK_MODEL }, true);
+            }
             return JSON.stringify({
                 error: result.error,
                 message: result.error.message || "API returned an error",
@@ -220,11 +268,16 @@ async function extractClaudeResponse(response) {
 /**
  * Internal implementation for streaming API calls
  */
-async function* callAIStreaming(prompt, options = {}) {
+async function* callAIStreaming(prompt, options = {}, isRetry = false) {
     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);
             throw new Error(`API returned error ${response.status}: ${response.statusText}`);

package/dist/types.d.ts

@@ -90,6 +90,11 @@ export interface CallAIOptions {
      * Used for multimodal models that can generate images
      */
     modalities?: string[];
+    /**
+     * Whether to skip retry with fallback model when model errors occur
+     * Useful in testing and cases where retries should be suppressed
+     */
+    skipRetry?: boolean;
     /**
      * Any additional options to pass to the API
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "call-ai",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Lightweight library for making AI API calls with streaming support",
   "main": "dist/index.js",
   "browser": "dist/index.js",
@@ -47,6 +47,7 @@
     "test:integration": "jest --testMatch=\"**/test/integration.test.ts\" --testPathIgnorePatterns=''",
     "typecheck": "tsc --noEmit",
     "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
-    "coverage": "jest --coverage"
+    "coverage": "jest --coverage",
+    "check": "npm run typecheck && npm run format && npm run test"
   }
 }