call-ai/error-handling.js

Lightweight library for making AI API calls with streaming support

import { globalDebug, isNewKeyError } from "./key-management.js";
import { CallAIError } from "./types.js";
async function handleApiError(ierror, context, debug = globalDebug, options = {}) {
    const error = ierror;
    const errorMessage = error?.message || String(error);
    const status = error?.status ||
        error?.statusCode ||
        error?.response?.status ||
        (errorMessage.match(/status: (\d+)/i)?.[1] && parseInt(errorMessage.match(/status: (\d+)/i)?.[1] ?? "500"));
    const isMissingKeyError = errorMessage.includes("API key is required");
    if (debug) {
        console.error(`[callAi:error] ${context} error:`, {
            message: errorMessage,
            status,
            name: error?.name,
            cause: error?.cause,
            isMissingKey: isMissingKeyError,
        });
    }
    if (options.skipRefresh) {
        throw error;
    }
    const needsAuth = isNewKeyError(error, debug) || isMissingKeyError;
    if (needsAuth && debug) {
        console.log(`[callAi:auth] Authentication error detected. Ensure proper authentication tokens are provided.`);
    }
    const detailedError = new CallAIError({
        message: `${context}: ${errorMessage}`,
        originalError: error,
        status: status || 500,
        errorType: error.name || "Error",
    });
    throw detailedError;
}
async function checkForInvalidModelError(response, model, debug = globalDebug) {
    if (response.status < 400 || response.status >= 500) {
        return { isInvalidModel: false };
    }
    const responseClone = response.clone();
    let errorData;
    try {
        errorData = (await responseClone.json());
    }
    catch (e) {
        try {
            const text = await responseClone.text();
            errorData = { error: text };
        }
        catch (e) {
            errorData = { error: `Error ${response.status}: ${response.statusText}` };
        }
    }
    const isInvalidModelError = response.status === 404 ||
        response.status === 400 ||
        (errorData &&
            errorData.error &&
            ((typeof errorData.error === "string" &&
                (errorData.error.toLowerCase().includes("model") ||
                    errorData.error.toLowerCase().includes("engine") ||
                    errorData.error.toLowerCase().includes("not found") ||
                    errorData.error.toLowerCase().includes("invalid") ||
                    errorData.error.toLowerCase().includes("unavailable"))) ||
                (typeof errorData.error === "object" &&
                    errorData.error.message &&
                    typeof errorData.error.message === "string" &&
                    (errorData.error.message.toLowerCase().includes("model") ||
                        errorData.error.message.toLowerCase().includes("engine") ||
                        errorData.error.message.toLowerCase().includes("not found") ||
                        errorData.error.message.toLowerCase().includes("invalid") ||
                        errorData.error.message.toLowerCase().includes("unavailable")))));
    if (debug && isInvalidModelError) {
        console.log(`[callAi:model-fallback] Detected invalid model error for "${model}":`, errorData);
    }
    return { isInvalidModel: Boolean(isInvalidModelError), errorData };
}
export { handleApiError, checkForInvalidModelError };
//# sourceMappingURL=error-handling.js.map