call-ai 0.8.3 → 0.8.5-dev-preview

package/dist/error-handling.d.ts

@@ -0,0 +1,12 @@
+declare function handleApiError(error: any, context: string, debug?: boolean, options?: {
+    apiKey?: string;
+    endpoint?: string;
+    skipRefresh?: boolean;
+    refreshToken?: string;
+    updateRefreshToken?: (currentToken: string) => Promise<string>;
+}): Promise<void>;
+declare function checkForInvalidModelError(response: Response, model: string, debug?: boolean): Promise<{
+    isInvalidModel: boolean;
+    errorData?: any;
+}>;
+export { handleApiError, checkForInvalidModelError };

package/dist/error-handling.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApiError = handleApiError;
+exports.checkForInvalidModelError = checkForInvalidModelError;
+/**
+ * Error handling utilities for call-ai
+ */
+const key_management_1 = require("./key-management");
+// Standardized API error handler
+// @param error The error object
+// @param context Context description for error messages
+// @param debug Whether to log debug information
+// @param options Options for error handling including key refresh control
+async function handleApiError(error, context, debug = key_management_1.globalDebug, options = {}) {
+    // Extract error details
+    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]));
+    if (debug) {
+        console.error(`[callAI:error] ${context} error:`, {
+            message: errorMessage,
+            status,
+            name: error?.name,
+            cause: error?.cause,
+        });
+    }
+    // Don't attempt API key refresh if explicitly skipped
+    if (options.skipRefresh) {
+        throw error;
+    }
+    // Determine if this error suggests we need a new API key
+    const needsNewKey = (0, key_management_1.isNewKeyError)(error, debug);
+    // If the error suggests an API key issue, try to refresh the key
+    if (needsNewKey) {
+        if (debug) {
+            console.log(`[callAI:key-refresh] Error suggests API key issue, attempting refresh...`);
+        }
+        try {
+            // Use provided key/endpoint/refreshToken or fallback to global configuration
+            const currentKey = options.apiKey || key_management_1.keyStore.current;
+            const endpoint = options.endpoint || key_management_1.keyStore.refreshEndpoint;
+            let refreshToken = options.refreshToken || key_management_1.keyStore.refreshToken;
+            // First attempt to refresh the API key
+            try {
+                const { apiKey, topup } = await (0, key_management_1.refreshApiKey)(currentKey, endpoint, refreshToken, debug);
+                // Update the key in the store (if not already set by refreshApiKey)
+                if (key_management_1.keyStore.current !== apiKey) {
+                    key_management_1.keyStore.current = apiKey;
+                }
+                if (debug) {
+                    console.log(`[callAI:key-refresh] ${topup ? "Topped up" : "Refreshed"} API key successfully`);
+                }
+                // Return without throwing since we've successfully recovered
+                return;
+            }
+            catch (initialRefreshError) {
+                // If there's an updateRefreshToken callback and the error was due to token issue
+                if (options.updateRefreshToken && refreshToken) {
+                    if (debug) {
+                        console.log(`[callAI:key-refresh] Initial refresh failed, attempting to update refresh token`);
+                    }
+                    try {
+                        // Get a new refresh token using the callback
+                        const newRefreshToken = await options.updateRefreshToken(refreshToken);
+                        if (newRefreshToken && newRefreshToken !== refreshToken) {
+                            if (debug) {
+                                console.log(`[callAI:key-refresh] Got new refresh token, retrying key refresh`);
+                            }
+                            // Update the stored refresh token
+                            key_management_1.keyStore.refreshToken = newRefreshToken;
+                            // Try again with the new token
+                            const { apiKey, topup } = await (0, key_management_1.refreshApiKey)(currentKey, endpoint, newRefreshToken, debug);
+                            // Update the key in the store
+                            if (key_management_1.keyStore.current !== apiKey) {
+                                key_management_1.keyStore.current = apiKey;
+                            }
+                            if (debug) {
+                                console.log(`[callAI:key-refresh] ${topup ? "Topped up" : "Refreshed"} API key successfully with new refresh token`);
+                            }
+                            // Return without throwing since we've successfully recovered
+                            return;
+                        }
+                        else {
+                            if (debug) {
+                                console.log(`[callAI:key-refresh] No new refresh token provided or same token returned, cannot retry`);
+                            }
+                            // Continue to error handling
+                            throw initialRefreshError;
+                        }
+                    }
+                    catch (tokenUpdateError) {
+                        if (debug) {
+                            console.error(`[callAI:key-refresh] Failed to update refresh token:`, tokenUpdateError);
+                        }
+                        // Continue to error handling with the original refresh error
+                        throw initialRefreshError;
+                    }
+                }
+                else {
+                    // No updateRefreshToken callback or no token, rethrow the initial error
+                    throw initialRefreshError;
+                }
+            }
+        }
+        catch (refreshError) {
+            // Log refresh failure but throw the original error
+            if (debug) {
+                console.error(`[callAI:key-refresh] API key refresh failed:`, refreshError);
+            }
+            // Create a more detailed error from the original one
+            const detailedError = new Error(`${errorMessage} (Key refresh failed: ${refreshError instanceof Error ? refreshError.message : String(refreshError)})`);
+            // Preserve error metadata from the original error
+            detailedError.originalError = error;
+            detailedError.refreshError = refreshError;
+            detailedError.status = status || 401;
+            throw detailedError;
+        }
+    }
+    // For non-key errors, create a detailed error object
+    const detailedError = new Error(`${context}: ${errorMessage}`);
+    detailedError.originalError = error;
+    detailedError.status = status || 500;
+    detailedError.errorType = error?.name || "Error";
+    throw detailedError;
+}
+// Helper to check if an error indicates invalid model and handle fallback
+async function checkForInvalidModelError(response, model, debug = key_management_1.globalDebug) {
+    // Only check 4xx errors (which could indicate invalid model)
+    if (response.status < 400 || response.status >= 500) {
+        return { isInvalidModel: false };
+    }
+    // Clone the response so we can still use the original later if needed
+    const responseClone = response.clone();
+    // Try to parse the response as JSON
+    let errorData;
+    try {
+        errorData = await responseClone.json();
+    }
+    catch (e) {
+        // If it's not JSON, get the text
+        try {
+            const text = await responseClone.text();
+            errorData = { error: text };
+        }
+        catch (textError) {
+            errorData = { error: `Error ${response.status}: ${response.statusText}` };
+        }
+    }
+    // Check if the error indicates an invalid model
+    const isInvalidModelError = 
+    // Status checks
+    response.status === 404 ||
+        response.status === 400 ||
+        // Response content checks
+        (errorData &&
+            ((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"))) ||
+                (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: isInvalidModelError, errorData };
+}

package/dist/image.js

@@ -19,18 +19,21 @@ async function imageGen(prompt, options = {}) {
     // Get custom origin if set
     const customOrigin = options.imgUrl ||
         (typeof window !== "undefined" ? window.CALLAI_IMG_URL : null) ||
-        (typeof process !== "undefined" && process.env ? process.env.CALLAI_IMG_URL : null);
+        (typeof process !== "undefined" && process.env
+            ? process.env.CALLAI_IMG_URL
+            : null);
     try {
         // Handle image generation
         if (!options.images || options.images.length === 0) {
             // Simple image generation with text prompt
             // Use custom origin or document.location.origin
-            const origin = customOrigin || (typeof document !== 'undefined' ? document.location.origin : '');
+            const origin = customOrigin ||
+                (typeof document !== "undefined" ? document.location.origin : "");
             const generateEndpoint = `${origin}/api/openai-image/generate`;
             const response = await fetch(generateEndpoint, {
                 method: "POST",
                 headers: {
-                    "Authorization": `Bearer ${apiKey}`,
+                    Authorization: `Bearer ${apiKey}`,
                     "Content-Type": "application/json",
                 },
                 body: JSON.stringify({
@@ -65,12 +68,13 @@ async function imageGen(prompt, options = {}) {
             if (options.style)
                 formData.append("style", options.style);
             // Use custom origin or document.location.origin
-            const origin = customOrigin || (typeof document !== 'undefined' ? document.location.origin : '');
+            const origin = customOrigin ||
+                (typeof document !== "undefined" ? document.location.origin : "");
             const editEndpoint = `${origin}/api/openai-image/edit`;
             const response = await fetch(editEndpoint, {
                 method: "POST",
                 headers: {
-                    "Authorization": `Bearer ${apiKey}`,
+                    Authorization: `Bearer ${apiKey}`,
                 },
                 body: formData,
             });

package/dist/index.d.ts

@@ -2,7 +2,7 @@
  * call-ai: A lightweight library for making AI API calls
  */
 export * from "./types";
-export { callAI } from "./api";
+export { callAI, getMeta } from "./api";
 export { imageGen } from "./image";
 export * from "./strategies";
 export * from "./utils";

package/dist/index.js

@@ -17,12 +17,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.imageGen = exports.callAI = void 0;
+exports.imageGen = exports.getMeta = exports.callAI = void 0;
 // Export public types
 __exportStar(require("./types"), exports);
-// Export API function
+// Export API functions
 var api_1 = require("./api");
 Object.defineProperty(exports, "callAI", { enumerable: true, get: function () { return api_1.callAI; } });
+Object.defineProperty(exports, "getMeta", { enumerable: true, get: function () { return api_1.getMeta; } });
 // Export image generation function
 var image_1 = require("./image");
 Object.defineProperty(exports, "imageGen", { enumerable: true, get: function () { return image_1.imageGen; } });

package/dist/key-management.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Key management functionality for call-ai
+ */
+declare const keyStore: {
+    current: string | null;
+    refreshEndpoint: string | null;
+    refreshToken: string | null;
+    isRefreshing: boolean;
+    lastRefreshAttempt: number;
+    metadata: Record<string, any>;
+};
+declare let globalDebug: boolean;
+/**
+ * Initialize key store with environment variables
+ */
+declare function initKeyStore(): void;
+/**
+ * Check if an error indicates we need a new API key
+ * @param error The error to check
+ * @param debug Whether to log debug information
+ * @returns True if the error suggests we need a new key
+ */
+declare function isNewKeyError(error: any, debug?: boolean): boolean;
+/**
+ * Refreshes the API key by calling the specified endpoint
+ * @param currentKey The current API key (may be null for initial key request)
+ * @param endpoint The endpoint to call for key refresh
+ * @param refreshToken Authentication token for the refresh endpoint
+ * @returns Object containing the API key and topup flag
+ */
+declare function refreshApiKey(currentKey: string | null, endpoint: string | null, refreshToken: string | null, debug?: boolean): Promise<{
+    apiKey: string;
+    topup: boolean;
+}>;
+/**
+ * Helper function to extract hash from key (implementation depends on how you store metadata)
+ */
+declare function getHashFromKey(key: string): string | null;
+/**
+ * Helper function to store key metadata for future reference
+ */
+declare function storeKeyMetadata(data: any): void;
+export { keyStore, globalDebug, initKeyStore, isNewKeyError, refreshApiKey, getHashFromKey, storeKeyMetadata, };

package/dist/key-management.js

@@ -0,0 +1,312 @@
+"use strict";
+/**
+ * Key management functionality for call-ai
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalDebug = exports.keyStore = void 0;
+exports.initKeyStore = initKeyStore;
+exports.isNewKeyError = isNewKeyError;
+exports.refreshApiKey = refreshApiKey;
+exports.getHashFromKey = getHashFromKey;
+exports.storeKeyMetadata = storeKeyMetadata;
+// Internal key store to keep track of the latest key
+const keyStore = {
+    // Default key from environment or config
+    current: null,
+    // The refresh endpoint URL - defaults to vibecode.garden
+    refreshEndpoint: "https://vibecode.garden",
+    // Authentication token for refresh endpoint - defaults to use-vibes
+    refreshToken: "use-vibes",
+    // Flag to prevent concurrent refresh attempts
+    isRefreshing: false,
+    // Timestamp of last refresh attempt (to prevent too frequent refreshes)
+    lastRefreshAttempt: 0,
+    // Storage for key metadata (useful for future top-up implementation)
+    metadata: {},
+};
+exports.keyStore = keyStore;
+// Global debug flag
+let globalDebug = false;
+exports.globalDebug = globalDebug;
+/**
+ * Initialize key store with environment variables
+ */
+function initKeyStore() {
+    // Initialize with environment variables if available
+    if (typeof process !== "undefined" && process.env) {
+        if (process.env.CALLAI_API_KEY) {
+            keyStore.current = process.env.CALLAI_API_KEY;
+        }
+        // Support both CALLAI_REFRESH_ENDPOINT and CALLAI_REKEY_ENDPOINT for backward compatibility
+        if (process.env.CALLAI_REFRESH_ENDPOINT) {
+            keyStore.refreshEndpoint = process.env.CALLAI_REFRESH_ENDPOINT;
+        }
+        else if (process.env.CALLAI_REKEY_ENDPOINT) {
+            keyStore.refreshEndpoint = process.env.CALLAI_REKEY_ENDPOINT;
+        }
+        else {
+            // Default to vibecode.garden if not specified
+            keyStore.refreshEndpoint = "https://vibecode.garden";
+        }
+        // Support both CALL_AI_REFRESH_TOKEN and CALL_AI_KEY_TOKEN for backward compatibility
+        if (process.env.CALL_AI_REFRESH_TOKEN) {
+            keyStore.refreshToken = process.env.CALL_AI_REFRESH_TOKEN;
+        }
+        else if (process.env.CALL_AI_KEY_TOKEN) {
+            keyStore.refreshToken = process.env.CALL_AI_KEY_TOKEN;
+        }
+        else {
+            // Default to use-vibes if not specified - this is the default token for vibecode.garden
+            keyStore.refreshToken = "use-vibes";
+        }
+        // Check for CALLAI_DEBUG environment variable (any truthy value works)
+        if (process.env.CALLAI_DEBUG) {
+            // Set the global debug flag
+            exports.globalDebug = globalDebug = true;
+        }
+    }
+    // Initialize from window globals if in browser context
+    else if (typeof window !== "undefined") {
+        // Use window.CALLAI_API_KEY or window.callAI.API_KEY if available
+        if (window.CALLAI_API_KEY) {
+            keyStore.current = window.CALLAI_API_KEY;
+        }
+        else if (window.callAI?.API_KEY) {
+            keyStore.current = window.callAI.API_KEY;
+        }
+        // Check for debug flag in browser environment
+        if (window.CALLAI_DEBUG) {
+            exports.globalDebug = globalDebug = true;
+        }
+        keyStore.refreshEndpoint =
+            window.CALLAI_REFRESH_ENDPOINT || keyStore.refreshEndpoint;
+        keyStore.refreshToken =
+            window.CALL_AI_REFRESH_TOKEN || keyStore.refreshToken;
+    }
+}
+// Initialize on module load
+initKeyStore();
+/**
+ * Check if an error indicates we need a new API key
+ * @param error The error to check
+ * @param debug Whether to log debug information
+ * @returns True if the error suggests we need a new key
+ */
+function isNewKeyError(error, debug = false) {
+    // Extract status from error object or message text
+    let status = error?.status || error?.statusCode || error?.response?.status;
+    const errorMessage = String(error || "").toLowerCase();
+    // Extract status code from error message if not found in the object properties
+    // Handle messages like "HTTP error! Status: 403" common in fetch errors
+    if (!status && errorMessage.includes("status:")) {
+        const statusMatch = errorMessage.match(/status:\\s*(\\d+)/i);
+        if (statusMatch && statusMatch[1]) {
+            status = parseInt(statusMatch[1], 10);
+        }
+    }
+    const is4xx = status >= 400 && status < 500;
+    // Check for various error types that indicate key issues
+    const isAuthError = status === 401 ||
+        status === 403 ||
+        errorMessage.includes("unauthorized") ||
+        errorMessage.includes("forbidden") ||
+        errorMessage.includes("authentication") ||
+        errorMessage.includes("api key") ||
+        errorMessage.includes("apikey") ||
+        errorMessage.includes("auth");
+    // More specific message checks, especially for common API providers
+    const isInvalidKeyError = errorMessage.includes("invalid api key") ||
+        errorMessage.includes("invalid key") ||
+        errorMessage.includes("incorrect api key") ||
+        errorMessage.includes("incorrect key") ||
+        errorMessage.includes("authentication failed") ||
+        errorMessage.includes("not authorized");
+    // Check for OpenAI specific error patterns
+    const isOpenAIKeyError = errorMessage.includes("openai") &&
+        (errorMessage.includes("api key") ||
+            errorMessage.includes("authentication"));
+    // Check for rate limit errors which might indicate a key top-up is needed
+    const isRateLimitError = status === 429 ||
+        errorMessage.includes("rate limit") ||
+        errorMessage.includes("too many requests") ||
+        errorMessage.includes("quota") ||
+        errorMessage.includes("exceed");
+    // Check for billing or payment errors
+    const isBillingError = errorMessage.includes("billing") ||
+        errorMessage.includes("payment") ||
+        errorMessage.includes("subscription") ||
+        errorMessage.includes("account");
+    // Simple heuristic: if it's a 4xx error with any key-related terms, likely needs key refresh
+    const needsNewKey = is4xx &&
+        (isAuthError ||
+            isInvalidKeyError ||
+            isOpenAIKeyError ||
+            isRateLimitError ||
+            isBillingError);
+    if (debug && needsNewKey) {
+        console.log(`[callAI:key-refresh] Detected error requiring key refresh: ${errorMessage}`);
+    }
+    return needsNewKey;
+}
+/**
+ * Refreshes the API key by calling the specified endpoint
+ * @param currentKey The current API key (may be null for initial key request)
+ * @param endpoint The endpoint to call for key refresh
+ * @param refreshToken Authentication token for the refresh endpoint
+ * @returns Object containing the API key and topup flag
+ */
+async function refreshApiKey(currentKey, endpoint, refreshToken, debug = globalDebug) {
+    // Ensure we have an endpoint and refreshToken
+    if (!endpoint) {
+        throw new Error("No API key refresh endpoint specified");
+    }
+    if (!refreshToken) {
+        throw new Error("No API key refresh token specified");
+    }
+    // Check if we're already in the process of refreshing (to prevent parallel refreshes)
+    if (keyStore.isRefreshing) {
+        if (debug) {
+            console.log("API key refresh already in progress, waiting...");
+        }
+        // Wait for refresh to complete (simple polling)
+        return new Promise((resolve) => {
+            const checkInterval = setInterval(() => {
+                if (!keyStore.isRefreshing && keyStore.current) {
+                    clearInterval(checkInterval);
+                    resolve({ apiKey: keyStore.current, topup: false });
+                }
+            }, 100);
+        });
+    }
+    // Rate limit key refresh to prevent overloading the service
+    const now = Date.now();
+    const timeSinceLastRefresh = now - keyStore.lastRefreshAttempt;
+    const minRefreshInterval = 2000; // 2 seconds minimum interval between refreshes
+    if (timeSinceLastRefresh < minRefreshInterval) {
+        if (debug) {
+            console.log(`Rate limiting key refresh, last attempt was ${timeSinceLastRefresh}ms ago`);
+        }
+        // If we've refreshed too recently, wait a bit
+        await new Promise((resolve) => setTimeout(resolve, minRefreshInterval - timeSinceLastRefresh));
+    }
+    // Set refreshing flag and update last attempt timestamp
+    keyStore.isRefreshing = true;
+    keyStore.lastRefreshAttempt = Date.now();
+    // Process API paths
+    let apiPath = "/api/keys";
+    // Normalize endpoint URL to remove any trailing slashes
+    const baseUrl = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+    // Construct the full URL
+    const url = `${baseUrl}${apiPath}`;
+    if (debug) {
+        console.log(`Refreshing API key from: ${url}`);
+    }
+    try {
+        // Request payload
+        const requestPayload = {
+            key: currentKey,
+            hash: currentKey ? getHashFromKey(currentKey) : null,
+            name: "call-ai-client", // Add the required name field
+        };
+        if (debug) {
+            console.log(`[callAI:key-refresh] Request URL: ${url}`);
+            console.log(`[callAI:key-refresh] Request headers:`, {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${refreshToken}`,
+            });
+            console.log(`[callAI:key-refresh] Request payload:`, requestPayload);
+        }
+        // Make the request
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${refreshToken}`,
+            },
+            body: JSON.stringify(requestPayload),
+        });
+        if (debug) {
+            console.log(`[callAI:key-refresh] Response status: ${response.status} ${response.statusText}`);
+            console.log(`[callAI:key-refresh] Response headers:`, Object.fromEntries([...response.headers.entries()]));
+        }
+        if (!response.ok) {
+            // Try to get the response body for more details
+            const errorText = await response.text();
+            if (debug) {
+                console.log(`[callAI:key-refresh] Error response body: ${errorText}`);
+            }
+            throw new Error(`API key refresh failed: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
+        }
+        // Parse the response
+        const data = await response.json();
+        // Log the complete response structure for debugging
+        if (debug) {
+            console.log(`[callAI:key-refresh] Full response structure:`, JSON.stringify(data, null, 2));
+        }
+        // Handle different API response formats
+        let newKey;
+        // Check if response has the new nested format with data.key.key
+        if (data.key && typeof data.key === "object" && data.key.key) {
+            newKey = data.key.key;
+        }
+        // Check for old format where data.key is the string key directly
+        else if (data.key && typeof data.key === "string") {
+            newKey = data.key;
+        }
+        // Handle error case
+        else {
+            throw new Error("Invalid response from key refresh endpoint: missing or malformed key");
+        }
+        if (debug) {
+            console.log(`API key refreshed successfully: ${newKey.substring(0, 10)}...`);
+        }
+        // Store metadata for potential future use (like top-up)
+        if (data.metadata ||
+            (data.key && typeof data.key === "object" && data.key.metadata)) {
+            const metadata = data.metadata || data.key.metadata;
+            storeKeyMetadata(metadata);
+        }
+        // Update the key store with the string value
+        keyStore.current = newKey;
+        // Determine if this was a top-up (using existing key) or new key
+        // For the new API response format, hash is in data.key.hash
+        const hashValue = data.hash || (data.key && typeof data.key === "object" && data.key.hash);
+        const isTopup = currentKey && hashValue && hashValue === getHashFromKey(currentKey);
+        // Reset refreshing flag
+        keyStore.isRefreshing = false;
+        return {
+            apiKey: newKey, // Return the string key, not the object
+            topup: isTopup,
+        };
+    }
+    catch (error) {
+        // Reset refreshing flag
+        keyStore.isRefreshing = false;
+        throw error;
+    }
+}
+/**
+ * Helper function to extract hash from key (implementation depends on how you store metadata)
+ */
+function getHashFromKey(key) {
+    if (!key)
+        return null;
+    // Simple implementation: just look up in our metadata store
+    const metaKey = Object.keys(keyStore.metadata).find((k) => k === key);
+    return metaKey ? keyStore.metadata[metaKey].hash || null : null;
+}
+/**
+ * Helper function to store key metadata for future reference
+ */
+function storeKeyMetadata(data) {
+    if (!data || !data.key)
+        return;
+    // Store metadata with the key as the dictionary key
+    keyStore.metadata[data.key] = {
+        hash: data.hash || null,
+        created: data.created || Date.now(),
+        expires: data.expires || null,
+        remaining: data.remaining || null,
+        limit: data.limit || null,
+    };
+}

package/dist/non-streaming.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Non-streaming API call implementation for call-ai
+ */
+import { CallAIOptions, Message, SchemaStrategy } from "./types";
+declare const PACKAGE_VERSION: any;
+declare const FALLBACK_MODEL = "openrouter/auto";
+declare function callAINonStreaming(prompt: string | Message[], options?: CallAIOptions, isRetry?: boolean): Promise<string>;
+declare function extractContent(result: any, schemaStrategy: SchemaStrategy): any;
+declare function extractClaudeResponse(response: Response): Promise<any>;
+export { callAINonStreaming, extractContent, extractClaudeResponse, PACKAGE_VERSION, FALLBACK_MODEL, };