call-ai 0.10.2 → 0.11.0-dev-preview3

package/dist/key-management.js

@@ -1,312 +0,0 @@
-"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/response-metadata.d.ts

@@ -1,18 +0,0 @@
-/**
- * Response metadata handling for call-ai
- */
-import { ResponseMeta } from "./types";
-declare const responseMetadata: WeakMap<object, ResponseMeta>;
-declare const stringResponseMap: Map<string, object>;
-/**
- * Helper to box a string so it can be used with WeakMap
- * @internal
- */
-declare function boxString(str: string): object;
-/**
- * Retrieve metadata associated with a response from callAi()
- * @param response A response from callAi, either string or AsyncGenerator
- * @returns The metadata object if available, undefined otherwise
- */
-declare function getMeta(response: string | AsyncGenerator<string, string, unknown>): ResponseMeta | undefined;
-export { responseMetadata, stringResponseMap, boxString, getMeta };

package/dist/response-metadata.js

@@ -1,44 +0,0 @@
-"use strict";
-/**
- * Response metadata handling for call-ai
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringResponseMap = exports.responseMetadata = void 0;
-exports.boxString = boxString;
-exports.getMeta = getMeta;
-// WeakMap to store metadata for responses without modifying the response objects
-const responseMetadata = new WeakMap();
-exports.responseMetadata = responseMetadata;
-// Store for string responses - we need to box strings since WeakMap keys must be objects
-const stringResponseMap = new Map();
-exports.stringResponseMap = stringResponseMap;
-/**
- * Helper to box a string so it can be used with WeakMap
- * @internal
- */
-function boxString(str) {
-    // Check if already boxed
-    if (stringResponseMap.has(str)) {
-        return stringResponseMap.get(str);
-    }
-    // Create a new box
-    const box = Object.create(null);
-    stringResponseMap.set(str, box);
-    return box;
-}
-/**
- * Retrieve metadata associated with a response from callAi()
- * @param response A response from callAi, either string or AsyncGenerator
- * @returns The metadata object if available, undefined otherwise
- */
-function getMeta(response) {
-    if (typeof response === "string") {
-        const box = stringResponseMap.get(response);
-        if (box) {
-            return responseMetadata.get(box);
-        }
-        return undefined;
-    }
-    // For AsyncGenerator and other objects, look up directly
-    return responseMetadata.get(response);
-}

package/dist/strategies/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * Strategy exports
- */
-export * from "./model-strategies";
-export * from "./strategy-selector";

package/dist/strategies/index.js

@@ -1,21 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-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 });
-/**
- * Strategy exports
- */
-__exportStar(require("./model-strategies"), exports);
-__exportStar(require("./strategy-selector"), exports);

package/dist/strategies/model-strategies.d.ts

@@ -1,24 +0,0 @@
-/**
- * Model strategies for different AI models
- */
-import { ModelStrategy } from "../types";
-/**
- * OpenAI/GPT strategy for handling JSON schema
- */
-export declare const openAIStrategy: ModelStrategy;
-/**
- * Gemini strategy for handling JSON schema (similar to OpenAI)
- */
-export declare const geminiStrategy: ModelStrategy;
-/**
- * Claude strategy using tool mode for structured output
- */
-export declare const claudeStrategy: ModelStrategy;
-/**
- * System message approach for other models (Llama, DeepSeek, etc.)
- */
-export declare const systemMessageStrategy: ModelStrategy;
-/**
- * Default strategy for models without schema
- */
-export declare const defaultStrategy: ModelStrategy;

package/dist/strategies/strategy-selector.d.ts

@@ -1,8 +0,0 @@
-/**
- * Strategy selection logic for different AI models
- */
-import { Schema, SchemaStrategy } from "../types";
-/**
- * Choose the appropriate schema strategy based on model and schema
- */
-export declare function chooseSchemaStrategy(model: string | undefined, schema: Schema | null): SchemaStrategy;

package/dist/strategies/strategy-selector.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.chooseSchemaStrategy = chooseSchemaStrategy;
-const model_strategies_1 = require("./model-strategies");
-/**
- * Choose the appropriate schema strategy based on model and schema
- */
-function chooseSchemaStrategy(model, schema) {
-    // Default model if not provided
-    const resolvedModel = model || (schema ? "openai/gpt-4o" : "openrouter/auto");
-    // No schema case - use default strategy
-    if (!schema) {
-        return {
-            strategy: "none",
-            model: resolvedModel,
-            prepareRequest: model_strategies_1.defaultStrategy.prepareRequest,
-            processResponse: model_strategies_1.defaultStrategy.processResponse,
-            shouldForceStream: false,
-        };
-    }
-    // Check for Claude models
-    if (/claude/i.test(resolvedModel)) {
-        return {
-            strategy: "tool_mode",
-            model: resolvedModel,
-            prepareRequest: model_strategies_1.claudeStrategy.prepareRequest,
-            processResponse: model_strategies_1.claudeStrategy.processResponse,
-            shouldForceStream: !!model_strategies_1.claudeStrategy.shouldForceStream,
-        };
-    }
-    // Check for Gemini models
-    if (/gemini/i.test(resolvedModel)) {
-        return {
-            strategy: "json_schema",
-            model: resolvedModel,
-            prepareRequest: model_strategies_1.geminiStrategy.prepareRequest,
-            processResponse: model_strategies_1.geminiStrategy.processResponse,
-            shouldForceStream: !!model_strategies_1.geminiStrategy.shouldForceStream,
-        };
-    }
-    // Check for GPT-4 Turbo models - use system message approach
-    if (/gpt-4-turbo/i.test(resolvedModel)) {
-        return {
-            strategy: "system_message",
-            model: resolvedModel,
-            prepareRequest: model_strategies_1.systemMessageStrategy.prepareRequest,
-            processResponse: model_strategies_1.systemMessageStrategy.processResponse,
-            shouldForceStream: !!model_strategies_1.systemMessageStrategy.shouldForceStream,
-        };
-    }
-    // Check for OpenAI models
-    if (/openai|gpt/i.test(resolvedModel)) {
-        return {
-            strategy: "json_schema",
-            model: resolvedModel,
-            prepareRequest: model_strategies_1.openAIStrategy.prepareRequest,
-            processResponse: model_strategies_1.openAIStrategy.processResponse,
-            shouldForceStream: !!model_strategies_1.openAIStrategy.shouldForceStream,
-        };
-    }
-    // Check for other specific models that need system message approach
-    if (/llama-3|deepseek/i.test(resolvedModel)) {
-        return {
-            strategy: "system_message",
-            model: resolvedModel,
-            prepareRequest: model_strategies_1.systemMessageStrategy.prepareRequest,
-            processResponse: model_strategies_1.systemMessageStrategy.processResponse,
-            shouldForceStream: !!model_strategies_1.systemMessageStrategy.shouldForceStream,
-        };
-    }
-    // Default to system message approach for unknown models with schema
-    return {
-        strategy: "system_message",
-        model: resolvedModel,
-        prepareRequest: model_strategies_1.systemMessageStrategy.prepareRequest,
-        processResponse: model_strategies_1.systemMessageStrategy.processResponse,
-        shouldForceStream: !!model_strategies_1.systemMessageStrategy.shouldForceStream,
-    };
-}

package/dist/streaming.d.ts

@@ -1,7 +0,0 @@
-/**
- * Streaming response handling for call-ai
- */
-import { CallAIOptions, SchemaStrategy } from "./types";
-declare function createStreamingGenerator(response: Response, options: CallAIOptions, schemaStrategy: SchemaStrategy, model: string): AsyncGenerator<string, string, unknown>;
-declare function callAIStreaming(prompt: string | any[], options?: CallAIOptions, isRetry?: boolean): AsyncGenerator<string, string, unknown>;
-export { createStreamingGenerator, callAIStreaming };