call-ai 0.10.2 → 0.11.0-dev-preview3

package/dist/api.js

@@ -1,498 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMeta = void 0;
-exports.callAi = callAi;
-const strategies_1 = require("./strategies");
-const response_metadata_1 = require("./response-metadata");
-Object.defineProperty(exports, "getMeta", { enumerable: true, get: function () { return response_metadata_1.getMeta; } });
-const key_management_1 = require("./key-management");
-const error_handling_1 = require("./error-handling");
-const api_core_1 = require("./api-core");
-const non_streaming_1 = require("./non-streaming");
-const streaming_1 = require("./streaming");
-// Import package version for debugging
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const PACKAGE_VERSION = require("../package.json").version;
-// 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
- * @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 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
-    const schemaStrategy = (0, strategies_1.chooseSchemaStrategy)(options.model, options.schema || null);
-    // We no longer set a default maxTokens
-    // Will only include max_tokens in the request if explicitly set by the user
-    // Handle special case: Claude with tools requires streaming
-    if (!options.stream && schemaStrategy.shouldForceStream) {
-        // Buffer streaming results into a single response
-        return bufferStreamingResults(prompt, options);
-    }
-    // Handle normal non-streaming mode
-    if (options.stream !== true) {
-        return callAINonStreaming(prompt, options);
-    }
-    // Handle streaming mode - return a Promise that resolves to an AsyncGenerator
-    // 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 });
-        // Use either explicit debug option or global debug flag
-        const debug = options.debug || key_management_1.globalDebug;
-        if (debug) {
-            console.log(`[callAi:${PACKAGE_VERSION}] Making fetch request to: ${endpoint}`);
-            console.log(`[callAi:${PACKAGE_VERSION}] With model: ${model}`);
-            console.log(`[callAi:${PACKAGE_VERSION}] Request headers:`, JSON.stringify(requestOptions.headers));
-        }
-        let response;
-        try {
-            response = await fetch(endpoint, requestOptions);
-            if (options.debug) {
-                console.log(`[callAi:${PACKAGE_VERSION}] Fetch completed with status:`, response.status, response.statusText);
-                // Log all headers
-                console.log(`[callAi:${PACKAGE_VERSION}] Response headers:`);
-                response.headers.forEach((value, name) => {
-                    console.log(`[callAi:${PACKAGE_VERSION}]   ${name}: ${value}`);
-                });
-                // Clone response for diagnostic purposes only
-                const diagnosticResponse = response.clone();
-                try {
-                    // Try to get the response as text for debugging
-                    const responseText = await diagnosticResponse.text();
-                    console.log(`[callAi:${PACKAGE_VERSION}] First 500 chars of response body:`, responseText.substring(0, 500) +
-                        (responseText.length > 500 ? "..." : ""));
-                }
-                catch (e) {
-                    console.log(`[callAi:${PACKAGE_VERSION}] Could not read response body for diagnostics:`, e);
-                }
-            }
-        }
-        catch (fetchError) {
-            if (options.debug) {
-                console.error(`[callAi:${PACKAGE_VERSION}] Network error during fetch:`, fetchError);
-            }
-            throw fetchError; // Re-throw network errors
-        }
-        // Explicitly check for HTTP error status and log extensively if debug is enabled
-        // Safe access to headers in case of mock environments
-        const contentType = response?.headers?.get?.("content-type") || "";
-        if (options.debug) {
-            console.log(`[callAi:${PACKAGE_VERSION}] Response.ok =`, response.ok);
-            console.log(`[callAi:${PACKAGE_VERSION}] Response.status =`, response.status);
-            console.log(`[callAi:${PACKAGE_VERSION}] Response.statusText =`, response.statusText);
-            console.log(`[callAi:${PACKAGE_VERSION}] Response.type =`, response.type);
-            console.log(`[callAi:${PACKAGE_VERSION}] Content-Type =`, contentType);
-        }
-        // Browser-compatible error handling - must check BOTH status code AND content-type
-        // Some browsers will report status 200 for SSE streams even when server returns 400
-        const hasHttpError = !response.ok || response.status >= 400;
-        const hasJsonError = contentType.includes("application/json");
-        if (hasHttpError || hasJsonError) {
-            if (options.debug) {
-                console.log(`[callAi:${PACKAGE_VERSION}] ⚠️ Error detected - HTTP Status: ${response.status}, Content-Type: ${contentType}`);
-            }
-            // Handle the error with fallback model if appropriate
-            if (!options.skipRetry) {
-                const clonedResponse = response.clone();
-                let isInvalidModel = false;
-                try {
-                    // Check if this is an invalid model error
-                    const modelCheckResult = await (0, error_handling_1.checkForInvalidModelError)(clonedResponse, model, options.debug);
-                    isInvalidModel = modelCheckResult.isInvalidModel;
-                    if (isInvalidModel) {
-                        if (options.debug) {
-                            console.log(`[callAi:${PACKAGE_VERSION}] Retrying with fallback model: ${FALLBACK_MODEL}`);
-                        }
-                        // Retry with fallback model
-                        return (await callAi(prompt, {
-                            ...options,
-                            model: FALLBACK_MODEL,
-                        }));
-                    }
-                }
-                catch (modelCheckError) {
-                    console.error(`[callAi:${PACKAGE_VERSION}] Error during model check:`, modelCheckError);
-                    // Continue with normal error handling
-                }
-            }
-            // Extract error details from response
-            try {
-                // Try to get error details from the response body
-                const errorBody = await response.text();
-                if (options.debug) {
-                    console.log(`[callAi:${PACKAGE_VERSION}] Error body:`, errorBody);
-                }
-                try {
-                    // Try to parse JSON error
-                    const errorJson = JSON.parse(errorBody);
-                    if (options.debug) {
-                        console.log(`[callAi:${PACKAGE_VERSION}] Parsed error:`, errorJson);
-                    }
-                    // Extract message from OpenRouter error format
-                    let errorMessage = "";
-                    // Handle common error formats
-                    if (errorJson.error &&
-                        typeof errorJson.error === "object" &&
-                        errorJson.error.message) {
-                        // OpenRouter/OpenAI format: { error: { message: "..." } }
-                        errorMessage = errorJson.error.message;
-                    }
-                    else if (errorJson.error && typeof errorJson.error === "string") {
-                        // Simple error format: { error: "..." }
-                        errorMessage = errorJson.error;
-                    }
-                    else if (errorJson.message) {
-                        // Generic format: { message: "..." }
-                        errorMessage = errorJson.message;
-                    }
-                    else {
-                        // Fallback with status details
-                        errorMessage = `API returned ${response.status}: ${response.statusText}`;
-                    }
-                    // Add status details to error message if not already included
-                    if (!errorMessage.includes(response.status.toString())) {
-                        errorMessage = `${errorMessage} (Status: ${response.status})`;
-                    }
-                    if (options.debug) {
-                        console.log(`[callAi:${PACKAGE_VERSION}] Extracted error message:`, errorMessage);
-                    }
-                    // Create error with standard format
-                    const error = new Error(errorMessage);
-                    // Add useful metadata
-                    error.status = response.status;
-                    error.statusText = response.statusText;
-                    error.details = errorJson;
-                    error.contentType = contentType;
-                    throw error;
-                }
-                catch (jsonError) {
-                    // If JSON parsing fails, extract a useful message from the raw error body
-                    if (options.debug) {
-                        console.log(`[callAi:${PACKAGE_VERSION}] JSON parse error:`, jsonError);
-                    }
-                    // Try to extract a useful message even from non-JSON text
-                    let errorMessage = "";
-                    // Check if it's a plain text error message
-                    if (errorBody && errorBody.trim().length > 0) {
-                        // Limit length for readability
-                        errorMessage =
-                            errorBody.length > 100
-                                ? errorBody.substring(0, 100) + "..."
-                                : errorBody;
-                    }
-                    else {
-                        errorMessage = `API error: ${response.status} ${response.statusText}`;
-                    }
-                    // Add status details if not already included
-                    if (!errorMessage.includes(response.status.toString())) {
-                        errorMessage = `${errorMessage} (Status: ${response.status})`;
-                    }
-                    if (options.debug) {
-                        console.log(`[callAi:${PACKAGE_VERSION}] Extracted text error message:`, errorMessage);
-                    }
-                    const error = new Error(errorMessage);
-                    error.status = response.status;
-                    error.statusText = response.statusText;
-                    error.details = errorBody;
-                    error.contentType = contentType;
-                    throw error;
-                }
-            }
-            catch (responseError) {
-                if (responseError instanceof Error) {
-                    // Re-throw if it's already properly formatted
-                    throw responseError;
-                }
-                // Fallback error
-                const error = new Error(`API returned ${response.status}: ${response.statusText}`);
-                error.status = response.status;
-                error.statusText = response.statusText;
-                error.contentType = contentType;
-                throw error;
-            }
-        }
-        // Only if response is OK, create and return the streaming generator
-        if (options.debug) {
-            console.log(`[callAi:${PACKAGE_VERSION}] Response OK, creating streaming generator`);
-        }
-        return (0, streaming_1.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") {
-        if (options.debug) {
-            console.warn(`[callAi:${PACKAGE_VERSION}] No await found - using legacy streaming pattern. This will be removed in a future version and may cause issues with certain models.`);
-        }
-    }
-    // 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 (0, api_core_1.createBackwardCompatStreamingProxy)(streamPromise);
-}
-/**
- * Buffer streaming results into a single response for cases where
- * we need to use streaming internally but the caller requested non-streaming
- */
-async function bufferStreamingResults(prompt, options) {
-    // Create a copy of options with streaming enabled
-    const streamingOptions = {
-        ...options,
-        stream: true,
-    };
-    try {
-        // Get streaming generator
-        const generator = (await callAi(prompt, streamingOptions));
-        // For Claude JSON responses, take only the last chunk (the final processed result)
-        // For all other cases, concatenate chunks as before
-        const isClaudeJson = /claude/.test(options.model || "") && options.schema;
-        if (isClaudeJson) {
-            // For Claude with JSON schema, we only want the last yielded value
-            // which will be the complete, properly processed JSON
-            let lastChunk = "";
-            for await (const chunk of generator) {
-                // Replace the last chunk entirely instead of concatenating
-                lastChunk = chunk;
-            }
-            return lastChunk;
-        }
-        else {
-            // For all other cases, concatenate chunks
-            let result = "";
-            for await (const chunk of generator) {
-                result += chunk;
-            }
-            return result;
-        }
-    }
-    catch (error) {
-        // Handle errors with standard API error handling
-        await (0, error_handling_1.handleApiError)(error, "Buffered streaming", options.debug, {
-            apiKey: options.apiKey,
-            endpoint: options.endpoint,
-            skipRefresh: options.skipRefresh,
-            refreshToken: options.refreshToken,
-            updateRefreshToken: options.updateRefreshToken,
-        });
-        // If we get here, key was refreshed successfully, retry the operation with the new key
-        // Retry with the refreshed key
-        return bufferStreamingResults(prompt, {
-            ...options,
-            apiKey: key_management_1.keyStore.current || undefined, // Use the refreshed key from keyStore
-        });
-    }
-    // This line should never be reached, but it satisfies the linter by ensuring
-    // all code paths return a value
-    throw new Error("Unexpected code path in bufferStreamingResults");
-}
-/**
- * Standardized API error handler
- */
-// createBackwardCompatStreamingProxy is imported from api-core.ts
-// handleApiError is imported from error-handling.ts
-// checkForInvalidModelError is imported from error-handling.ts
-/**
- * Prepare request parameters common to both streaming and non-streaming calls
- */
-function prepareRequestParams(prompt, options) {
-    // First try to get the API key from options or window globals
-    let apiKey = options.apiKey ||
-        key_management_1.keyStore.current || // Try keyStore first in case it was refreshed in a previous call
-        (typeof window !== "undefined" ? window.CALLAI_API_KEY : null);
-    const schema = options.schema || null;
-    // If no API key exists, we won't throw immediately. We'll continue and let handleApiError
-    // attempt to fetch a key if needed. This will be handled later in the call chain.
-    // Select the appropriate strategy based on model and schema
-    const schemaStrategy = (0, strategies_1.chooseSchemaStrategy)(options.model, schema);
-    const model = schemaStrategy.model;
-    // Get custom chat API origin if set
-    const customChatOrigin = options.chatUrl ||
-        (typeof window !== "undefined" ? window.CALLAI_CHAT_URL : null) ||
-        (typeof process !== "undefined" && process.env
-            ? process.env.CALLAI_CHAT_URL
-            : null);
-    // Use custom origin or default OpenRouter URL
-    const endpoint = options.endpoint ||
-        (customChatOrigin
-            ? `${customChatOrigin}/api/v1/chat/completions`
-            : "https://openrouter.ai/api/v1/chat/completions");
-    // Handle both string prompts and message arrays for backward compatibility
-    const messages = Array.isArray(prompt)
-        ? prompt
-        : [{ role: "user", content: prompt }];
-    // Common parameters for both streaming and non-streaming
-    const requestParams = {
-        model,
-        messages,
-        stream: options.stream !== undefined ? options.stream : false,
-    };
-    // Only include temperature if explicitly set
-    if (options.temperature !== undefined) {
-        requestParams.temperature = options.temperature;
-    }
-    // Only include top_p if explicitly set
-    if (options.topP !== undefined) {
-        requestParams.top_p = options.topP;
-    }
-    // Only include max_tokens if explicitly set
-    if (options.maxTokens !== undefined) {
-        requestParams.max_tokens = options.maxTokens;
-    }
-    // Add optional parameters if specified
-    if (options.stop) {
-        // Handle both single string and array of stop sequences
-        requestParams.stop = Array.isArray(options.stop)
-            ? options.stop
-            : [options.stop];
-    }
-    // Add response_format parameter for models that support JSON output
-    if (options.responseFormat === "json") {
-        requestParams.response_format = { type: "json_object" };
-    }
-    // Add schema structure if provided (for function calling/JSON mode)
-    if (schema) {
-        // Apply schema-specific parameters using the selected strategy
-        Object.assign(requestParams, schemaStrategy.prepareRequest(schema, messages));
-    }
-    // HTTP headers for the request
-    const headers = {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json",
-        "HTTP-Referer": options.referer || "https://vibes.diy",
-        "X-Title": options.title || "Vibes",
-    };
-    // Add any additional headers
-    if (options.headers) {
-        Object.assign(headers, options.headers);
-    }
-    // Build the requestOptions object for fetch
-    const requestOptions = {
-        method: "POST",
-        headers: {
-            ...headers,
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify(requestParams),
-    };
-    // If we don't have an API key, throw a clear error that can be caught and handled
-    // by the error handling system to trigger key fetching
-    if (!apiKey) {
-        throw new Error("API key is required. Provide it via options.apiKey or set window.CALLAI_API_KEY");
-    }
-    // Debug logging for request payload
-    if (options.debug) {
-        console.log(`[callAi-prepareRequest:raw] Endpoint: ${endpoint}`);
-        console.log(`[callAi-prepareRequest:raw] Model: ${model}`);
-        console.log(`[callAi-prepareRequest:raw] Payload:`, JSON.stringify(requestParams));
-    }
-    return { apiKey, model, endpoint, requestOptions, schemaStrategy };
-}
-/**
- * Internal implementation for non-streaming API calls
- */
-async function callAINonStreaming(prompt, options = {}, isRetry = false) {
-    try {
-        // Start timing for metadata
-        const startTime = Date.now();
-        // Create metadata object
-        const meta = {
-            model: options.model || "unknown",
-            timing: {
-                startTime: startTime,
-            },
-        };
-        const { endpoint, requestOptions, model, schemaStrategy } = prepareRequestParams(prompt, options);
-        const response = await fetch(endpoint, requestOptions);
-        // We don't store the raw Response object in metadata anymore
-        // Handle HTTP errors, with potential fallback for invalid model
-        if (!response.ok || response.status >= 400) {
-            const { isInvalidModel } = await (0, error_handling_1.checkForInvalidModelError)(response, model, options.debug);
-            if (isInvalidModel) {
-                // Retry with fallback model
-                return callAINonStreaming(prompt, { ...options, model: FALLBACK_MODEL }, true);
-            }
-            // Create a proper error object with the status code preserved
-            const error = new Error(`HTTP error! Status: ${response.status}`);
-            // Add status code as a property of the error object
-            error.status = response.status;
-            error.statusCode = response.status; // Add statusCode for compatibility with different error patterns
-            throw error;
-        }
-        let result;
-        // For Claude, use text() instead of json() to avoid potential hanging
-        if (/claude/i.test(model)) {
-            try {
-                result = await (0, non_streaming_1.extractClaudeResponse)(response);
-            }
-            catch (error) {
-                (0, error_handling_1.handleApiError)(error, "Claude API response processing failed", options.debug);
-            }
-        }
-        else {
-            result = await response.json();
-        }
-        // Debug logging for raw API response
-        if (options.debug) {
-            console.log(`[callAi-nonStreaming:raw] Response:`, JSON.stringify(result));
-        }
-        // Handle error responses
-        if (result.error) {
-            if (options.debug) {
-                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")) {
-                if (options.debug) {
-                    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",
-            });
-        }
-        // Extract content from the response
-        const content = (0, non_streaming_1.extractContent)(result, schemaStrategy);
-        // Store the raw response data for user access
-        if (result) {
-            // Store the parsed JSON result from the API call
-            meta.rawResponse = result;
-        }
-        // Update model info
-        meta.model = model;
-        // Update timing info
-        if (meta.timing) {
-            meta.timing.endTime = Date.now();
-            meta.timing.duration = meta.timing.endTime - meta.timing.startTime;
-        }
-        // Process the content based on model type
-        const processedContent = schemaStrategy.processResponse(content);
-        // Box the string for WeakMap storage
-        const boxed = (0, response_metadata_1.boxString)(processedContent);
-        response_metadata_1.responseMetadata.set(boxed, meta);
-        return processedContent;
-    }
-    catch (error) {
-        await (0, error_handling_1.handleApiError)(error, "Non-streaming API call", options.debug, {
-            apiKey: options.apiKey,
-            endpoint: options.endpoint,
-            skipRefresh: options.skipRefresh,
-            refreshToken: options.refreshToken,
-            updateRefreshToken: options.updateRefreshToken,
-        });
-        // If we get here, key was refreshed successfully, retry the operation with the new key
-        // Retry with the refreshed key
-        return callAINonStreaming(prompt, {
-            ...options,
-            apiKey: key_management_1.keyStore.current || undefined, // Use the refreshed key from keyStore
-        }, true); // Set isRetry to true
-    }
-    // This line will never be reached, but it satisfies the linter
-    throw new Error("Unexpected code path in callAINonStreaming");
-}

package/dist/image.d.ts

@@ -1,12 +0,0 @@
-/**
- * Image generation API implementation for call-ai
- * Integration with custom image generation API
- */
-import { ImageGenOptions, ImageResponse } from "./types";
-/**
- * Generate images using a custom API that mimics OpenAI's image generation capabilities
- * @param prompt Text prompt describing the image to generate
- * @param options Configuration options for the image generation request
- * @returns A Promise that resolves to the image response containing base64 encoded image data
- */
-export declare function imageGen(prompt: string, options?: ImageGenOptions): Promise<ImageResponse>;

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,32 +0,0 @@
-"use strict";
-/**
- * call-ai: A lightweight library for making AI API calls
- */
-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 });
-exports.imageGen = exports.callAI = exports.getMeta = exports.callAi = void 0;
-// Export public types
-__exportStar(require("./types"), exports);
-// 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; } });
-// Backward compatibility for callAI (uppercase AI)
-var api_2 = require("./api");
-Object.defineProperty(exports, "callAI", { enumerable: true, get: function () { return api_2.callAi; } });
-// 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

@@ -1,43 +0,0 @@
-/**
- * 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, };