call-ai 2.0.3 → 2.0.7

package/index.d.ts

@@ -2,6 +2,5 @@ export * from "./types.js";
 export { callAi } from "./api.js";
 export { callAi as callAI } from "./api.js";
 export { getMeta } from "./response-metadata.js";
-export { imageGen } from "./image.js";
 export { entriesHeaders, joinUrlParts } from "./utils.js";
 export { callAiEnv } from "./env.js";

package/index.js

@@ -2,7 +2,6 @@ export * from "./types.js";
 export { callAi } from "./api.js";
 export { callAi as callAI } from "./api.js";
 export { getMeta } from "./response-metadata.js";
-export { imageGen } from "./image.js";
 export { entriesHeaders, joinUrlParts } from "./utils.js";
 export { callAiEnv } from "./env.js";
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../jsr/index.ts"],"names":[],"mappings":"AAKA,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,OAAO,EAAE,MAAM,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAGjD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../jsr/index.ts"],"names":[],"mappings":"AAKA,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,OAAO,EAAE,MAAM,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAIjD,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "call-ai",
-  "version": "2.0.3",
+  "version": "2.0.7",
   "description": "Lightweight library for making AI API calls with streaming support",
   "type": "module",
   "main": "./index.js",

package/types.d.ts

@@ -230,7 +230,7 @@ export interface ImageResponse {
         readonly revised_prompt?: string;
     }[];
 }
-export interface ImageGenOptions {
+export interface ImgVibesOptions {
     readonly apiKey?: string;
     readonly model?: string;
     readonly size?: string;
@@ -242,5 +242,5 @@ export interface ImageGenOptions {
     readonly debug?: boolean;
     readonly mock?: Mocks;
 }
-export type ImageEditOptions = ImageGenOptions;
+export type ImageEditOptions = ImgVibesOptions;
 export {};

package/api.ts.off

@@ -1,595 +0,0 @@
-/**
- * Core API implementation for call-ai
- */
-import { CallAIError, CallAIErrorParams, CallAIOptions, Message, ResponseMeta, SchemaStrategy, StreamResponse } from "./types.js";
-import { chooseSchemaStrategy } from "./strategies/index.js";
-import { responseMetadata, boxString } from "./response-metadata.js";
-import { keyStore, globalDebug } from "./key-management.js";
-import { handleApiError, checkForInvalidModelError } from "./error-handling.js";
-import { createBackwardCompatStreamingProxy } from "./api-core.js";
-import { extractContent, extractClaudeResponse } from "./non-streaming.js";
-import { createStreamingGenerator } from "./streaming.js";
-import { PACKAGE_VERSION } from "./version.js";
-import { callAiEnv, callAiFetch } from "./utils.js";
-
-// Key management is now imported from ./key-management
-
-// initKeyStore is imported from key-management.ts
-// No need to call initKeyStore() here as it's called on module load in key-management.ts
-
-// isNewKeyError is imported from key-management.ts
-
-// refreshApiKey is imported from key-management.ts
-
-// getHashFromKey is imported from key-management.ts
-
-// storeKeyMetadata is imported from key-management.ts
-
-// Response metadata is now imported from ./response-metadata
-
-// boxString and getMeta functions are now imported from ./response-metadata
-// Re-export getMeta to maintain backward compatibility
-// export { getMeta };
-
-// Import package version for debugging
-
-// 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.
- */
-export function callAi(prompt: string | Message[], options: CallAIOptions = {}): Promise<string | StreamResponse> {
-  // Check if we need to force streaming based on model strategy
-  const schemaStrategy = 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 || 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 callAiFetch(options)(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 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,
-            })) as StreamResponse;
-          }
-        } 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 CallAIError({
-            message: errorMessage,
-            status: response.status,
-            statusText: response.statusText,
-            details: errorJson,
-            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 CallAIError({
-            message: errorMessage,
-            status: response.status,
-            statusText: response.statusText,
-            details: errorBody,
-            contentType,
-          });
-          throw error;
-        }
-      } catch (responseError) {
-        if (responseError instanceof Error) {
-          // Re-throw if it's already properly formatted
-          throw responseError;
-        }
-
-        // Fallback error
-        const error = new CallAIError({
-          message: `API returned ${response.status}: ${response.statusText}`,
-          status: response.status,
-          statusText: response.statusText,
-          details: undefined,
-          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 createStreamingGenerator(response, options, schemaStrategy, model);
-  })();
-
-  // For backward compatibility with v0.6.x where users didn't await the result
-  if (callAiEnv.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 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: string | Message[], options: CallAIOptions): Promise<string> {
-  // Create a copy of options with streaming enabled
-  const streamingOptions = {
-    ...options,
-    stream: true,
-  };
-
-  try {
-    // Get streaming generator
-    const generator = (await callAi(prompt, streamingOptions)) as AsyncGenerator<string, string, unknown>;
-
-    // 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 handleApiError(error as CallAIErrorParams, "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: 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: string | Message[],
-  options: CallAIOptions,
-): {
-  apiKey: string;
-  model: string;
-  endpoint: string;
-  requestOptions: RequestInit;
-  schemaStrategy: SchemaStrategy;
-} {
-  // First try to get the API key from options or window globals
-  const apiKey = options.apiKey || keyStore.current || callAiEnv.CALLAI_API_KEY; // Try keyStore first in case it was refreshed in a previous call
-  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 = chooseSchemaStrategy(options.model, schema);
-  const model = schemaStrategy.model;
-
-  // Get custom chat API origin if set
-  const customChatOrigin = options.chatUrl || callAiEnv.CALLAI_CHAT_URL;
-
-  // 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: Message[] = Array.isArray(prompt) ? prompt : [{ role: "user", content: prompt }];
-
-  // Common parameters for both streaming and non-streaming
-  const requestParams: CallAIOptions = {
-    model,
-    messages,
-    stream: options.stream !== undefined ? options.stream : false,
-  };
-
-  // Only include temperature if explicitly set
-  if (options.temperature) {
-    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: Record<string, string> = {
-    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: RequestInit = {
-    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: string | Message[], options: CallAIOptions = {}, isRetry = false): Promise<string> {
-  try {
-    // Start timing for metadata
-    const startTime = Date.now();
-
-    // Create metadata object
-    const meta: ResponseMeta = {
-      model: options.model || "unknown",
-      timing: {
-        startTime: startTime,
-      },
-    };
-    const { endpoint, requestOptions, model, schemaStrategy } = prepareRequestParams(prompt, options);
-
-    const response = await callAiFetch(options)(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 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 CallAIError({
-        message: `HTTP error! Status: ${response.status}`,
-        status: response.status,
-        statusText: response.statusText,
-        details: undefined,
-        contentType: "text/plain",
-      });
-      throw error;
-    }
-
-    let result;
-
-    // For Claude, use text() instead of json() to avoid potential hanging
-    if (/claude/i.test(model)) {
-      try {
-        result = await extractClaudeResponse(response);
-      } catch (error) {
-        handleApiError(error as CallAIErrorParams, "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 = 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 = boxString(processedContent);
-    responseMetadata.set(boxed, meta);
-
-    return processedContent;
-  } catch (error) {
-    await 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: 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/image.d.ts

@@ -1,2 +0,0 @@
-import { ImageGenOptions, ImageResponse } from "./types.js";
-export declare function imageGen(prompt: string, options?: ImageGenOptions): Promise<ImageResponse>;

package/image.js

@@ -1,80 +0,0 @@
-import { callAiFetch, joinUrlParts } from "./utils.js";
-import { callAiEnv } from "./env.js";
-export async function imageGen(prompt, options = {}) {
-    const { model = "google/gemini-2.5-flash-image", apiKey = callAiEnv.CALLAI_API_KEY, size = "1024x1024" } = options;
-    if (!apiKey) {
-        throw new Error("API key is required for image generation. Provide via options.apiKey or set window.CALLAI_API_KEY");
-    }
-    const customOrigin = options.imgUrl || callAiEnv.CALLAI_IMG_URL;
-    if (!options.images || options.images.length === 0) {
-        const generateEndpoint = options.endpoint || joinUrlParts(customOrigin || callAiEnv.def.CALLAI_CHAT_URL, "/api/openrouter-image/generate");
-        if (!apiKey) {
-            throw new Error("API key is required for image generation (simple)");
-        }
-        const headers = new Headers({
-            Authorization: `Bearer ${apiKey}`,
-            "Content-Type": "application/json",
-        });
-        const response = await callAiFetch(options)(generateEndpoint, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({
-                model,
-                prompt,
-                size,
-                ...(options.quality && { quality: options.quality }),
-                ...(options.style && { style: options.style }),
-            }),
-        });
-        if (!response.ok) {
-            const errorData = await response.text();
-            throw new Error(`Image generation failed: ${response.status} ${response.statusText} - ${errorData}`);
-        }
-        const responseText = await response.text();
-        try {
-            const result = JSON.parse(responseText);
-            return result;
-        }
-        catch (parseError) {
-            throw new Error(`Failed to parse JSON response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
-        }
-    }
-    else {
-        const formData = new FormData();
-        formData.append("model", model);
-        formData.append("prompt", prompt);
-        options.images.forEach((image, index) => {
-            formData.append(`image_${index}`, image);
-        });
-        formData.append("size", size);
-        if (options.quality)
-            formData.append("quality", options.quality);
-        if (options.style)
-            formData.append("style", options.style);
-        const editEndpoint = options.endpoint || joinUrlParts(customOrigin || callAiEnv.def.CALLAI_CHAT_URL, "/api/openrouter-image/edit");
-        if (!apiKey) {
-            throw new Error("API key is required for image generation (edit)");
-        }
-        const headers = new Headers({
-            Authorization: `Bearer ${apiKey}`,
-        });
-        const response = await callAiFetch(options)(editEndpoint, {
-            method: "POST",
-            headers,
-            body: formData,
-        });
-        if (!response.ok) {
-            const errorData = await response.text();
-            throw new Error(`Image editing failed: ${response.status} ${response.statusText} - ${errorData}`);
-        }
-        const responseText = await response.text();
-        try {
-            const result = JSON.parse(responseText);
-            return result;
-        }
-        catch (parseError) {
-            throw new Error(`Failed to parse JSON response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`);
-        }
-    }
-}
-//# sourceMappingURL=image.js.map

package/image.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"image.js","sourceRoot":"","sources":["../jsr/image.ts"],"names":[],"mappings":"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"}

package/index.ts.bak

@@ -1,16 +0,0 @@
-/**
- * call-ai: A lightweight library for making AI API calls
- */
-
-// Export public types
-export * from "./types";
-
-// Export API functions
-export { callAi, getMeta } from "./api";
-
-// Export image generation function
-export { imageGen } from "./image";
-
-// Export strategies and utilities for advanced use cases
-export * from "./strategies";
-export * from "./utils";

package/streaming.ts.off

@@ -1,571 +0,0 @@
-/**
- * Streaming response handling for call-ai
- */
-
-import { CallAIError, CallAIOptions, Message, ResponseMeta, SchemaAIMessageRequest, SchemaStrategy, ToolUseType } from "./types.js";
-import { globalDebug } from "./key-management.js";
-import { responseMetadata, boxString } from "./response-metadata.js";
-import { checkForInvalidModelError } from "./error-handling.js";
-import { PACKAGE_VERSION, FALLBACK_MODEL } from "./non-streaming.js";
-import { callAiFetch } from "./utils.js";
-
-// Generator factory function for streaming API calls
-// This is called after the fetch is made and response is validated
-//
-// Note: Even though we checked response.ok before creating this generator,
-// we need to be prepared for errors that may occur during streaming. Some APIs
-// return a 200 OK initially but then deliver error information in the stream.
-async function* createStreamingGenerator(
-  response: Response,
-  options: CallAIOptions,
-  schemaStrategy: SchemaStrategy,
-  model: string,
-): AsyncGenerator<string, string, unknown> {
-  // Create a metadata object for this streaming response
-  const meta: ResponseMeta = {
-    model,
-    endpoint: options.endpoint || "https://openrouter.ai/api/v1",
-    timing: {
-      startTime: Date.now(),
-      endTime: 0,
-      duration: 0,
-    },
-  };
-
-  // Tool calls assembly (for Claude/Anthropic)
-  let toolCallsAssembled = "";
-  let completeText = "";
-  let chunkCount = 0;
-
-  if (options.debug || globalDebug) {
-    console.log(`[callAi:${PACKAGE_VERSION}] Starting streaming generator with model: ${model}`);
-  }
-
-  try {
-    // Handle streaming response
-    const reader = response.body?.getReader();
-    if (!reader) {
-      throw new Error("Response body is undefined - API endpoint may not support streaming");
-    }
-
-    const textDecoder = new TextDecoder();
-    let buffer = ""; // Buffer to accumulate partial SSE messages
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        if (options.debug || globalDebug) {
-          console.log(`[callAi-streaming:complete v${PACKAGE_VERSION}] Stream finished after ${chunkCount} chunks`);
-        }
-        break;
-      }
-
-      // Convert bytes to text
-      const chunk = textDecoder.decode(value, { stream: true });
-      buffer += chunk;
-
-      // Split on double newlines to find complete SSE messages
-      const messages = buffer.split(/\n\n/);
-      buffer = messages.pop() || ""; // Keep the last incomplete chunk in the buffer
-
-      for (const message of messages) {
-        if (!message.trim() || !message.startsWith("data: ")) {
-          continue; // Skip empty lines or non-data messages
-        }
-
-        // Extract the JSON payload
-        const jsonStr = message.slice("data: ".length); // Remove 'data: ' prefix
-        if (jsonStr === "[DONE]") {
-          if (options.debug || globalDebug) {
-            console.log(`[callAi:${PACKAGE_VERSION}] Received [DONE] signal`);
-          }
-          continue;
-        }
-
-        chunkCount++;
-
-        // Try to parse the JSON
-        try {
-          console.log(`[callAi:${PACKAGE_VERSION}] Raw chunk #${chunkCount}:`, jsonStr);
-          const json = JSON.parse(jsonStr);
-
-          // Check for error responses in the stream
-          if (
-            json.error ||
-            json.type === "error" ||
-            (json.choices && json.choices.length > 0 && json.choices[0].finish_reason === "error")
-          ) {
-            // Extract error message
-            const errorMessage =
-              json.error?.message || json.error || json.choices?.[0]?.message?.content || "Unknown streaming error";
-
-            if (options.debug || globalDebug) {
-              console.error(`[callAi:${PACKAGE_VERSION}] Detected error in streaming response:`, json);
-            }
-
-            // Create a detailed error to throw
-            const detailedError = new CallAIError({
-              message: `API streaming error: ${errorMessage}`,
-              status: json.error?.status || 400,
-              statusText: json.error?.type || "Bad Request",
-              details: JSON.stringify(json.error || json),
-              contentType: "application/json",
-            });
-            console.error(`[callAi:${PACKAGE_VERSION}] Throwing stream error:`, detailedError);
-            throw detailedError;
-          }
-
-          // Handle tool use response - Claude with schema cases
-          const isClaudeWithSchema = /claude/i.test(model) && schemaStrategy.strategy === "tool_mode";
-
-          if (isClaudeWithSchema) {
-            // Claude streaming tool calls - need to assemble arguments
-            if (json.choices && json.choices.length > 0) {
-              const choice = json.choices[0];
-
-              // Handle finish reason tool_calls - this is where we know the tool call is complete
-              if (choice.finish_reason === "tool_calls") {
-                if (options.debug) {
-                  console.log(`[callAi:${PACKAGE_VERSION}] Received tool_calls finish reason. Assembled JSON:`, toolCallsAssembled);
-                }
-
-                // Full JSON collected, construct a proper object with it
-                try {
-                  // Try to fix any malformed JSON that might have resulted from chunking
-                  // This happens when property names get split across chunks
-                  if (toolCallsAssembled) {
-                    try {
-                      // First try parsing as-is
-                      JSON.parse(toolCallsAssembled);
-                      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                    } catch (e) {
-                      if (options.debug) {
-                        console.log(
-                          `[callAi:${PACKAGE_VERSION}] Attempting to fix malformed JSON in tool call:`,
-                          toolCallsAssembled,
-                        );
-                      }
-
-                      // Apply comprehensive fixes for Claude's JSON property splitting
-                      let fixedJson = toolCallsAssembled;
-
-                      // 1. Remove trailing commas
-                      fixedJson = fixedJson.replace(/,\s*([}\]])/, "$1");
-
-                      // 2. Ensure proper JSON structure
-                      // Add closing braces if missing
-                      const openBraces = (fixedJson.match(/\{/g) || []).length;
-                      const closeBraces = (fixedJson.match(/\}/g) || []).length;
-                      if (openBraces > closeBraces) {
-                        fixedJson += "}".repeat(openBraces - closeBraces);
-                      }
-
-                      // Add opening brace if missing
-                      if (!fixedJson.trim().startsWith("{")) {
-                        fixedJson = "{" + fixedJson.trim();
-                      }
-
-                      // Ensure it ends with a closing brace
-                      if (!fixedJson.trim().endsWith("}")) {
-                        fixedJson += "}";
-                      }
-
-                      // 3. Fix various property name/value split issues
-                      // Fix dangling property names without values
-                      fixedJson = fixedJson.replace(/"(\w+)"\s*:\s*$/g, '"$1":null');
-
-                      // Fix missing property values
-                      fixedJson = fixedJson.replace(/"(\w+)"\s*:\s*,/g, '"$1":null,');
-
-                      // Fix incomplete property names (when split across chunks)
-                      fixedJson = fixedJson.replace(/"(\w+)"\s*:\s*"(\w+)$/g, '"$1$2"');
-
-                      // Balance brackets
-                      const openBrackets = (fixedJson.match(/\[/g) || []).length;
-                      const closeBrackets = (fixedJson.match(/\]/g) || []).length;
-                      if (openBrackets > closeBrackets) {
-                        fixedJson += "]".repeat(openBrackets - closeBrackets);
-                      }
-
-                      if (options.debug) {
-                        console.log(
-                          `[callAi:${PACKAGE_VERSION}] Applied comprehensive JSON fixes:`,
-                          `\nBefore: ${toolCallsAssembled}`,
-                          `\nAfter: ${fixedJson}`,
-                        );
-                      }
-
-                      toolCallsAssembled = fixedJson;
-                    }
-                  }
-
-                  // Return the assembled tool call
-                  completeText = toolCallsAssembled;
-                  yield completeText;
-                  continue;
-                } catch (e) {
-                  console.error("[callAIStreaming] Error handling assembled tool call:", e);
-                }
-              }
-
-              // Assemble tool_calls arguments from delta
-              // Simply accumulate the raw strings without trying to parse them
-              if (choice && choice.delta && choice.delta.tool_calls) {
-                const toolCall = choice.delta.tool_calls[0];
-                if (toolCall && toolCall.function && toolCall.function.arguments !== undefined) {
-                  toolCallsAssembled += toolCall.function.arguments;
-                  if (options.debug) {
-                    console.log(`[callAi:${PACKAGE_VERSION}] Accumulated tool call chunk:`, toolCall.function.arguments);
-                  }
-                }
-              }
-            }
-          }
-
-          // Handle tool use response - old format
-          if (isClaudeWithSchema && (json.stop_reason === "tool_use" || json.type === "tool_use")) {
-            // First try direct tool use object format
-            if (json.type === "tool_use") {
-              completeText = schemaStrategy.processResponse(json);
-              yield completeText;
-              continue;
-            }
-
-            // Extract the tool use content
-            if (json.content && Array.isArray(json.content)) {
-              const toolUseBlock = json.content.find((block: ToolUseType) => block.type === "tool_use");
-              if (toolUseBlock) {
-                completeText = schemaStrategy.processResponse(toolUseBlock);
-                yield completeText;
-                continue;
-              }
-            }
-
-            // Find tool_use in assistant's content blocks
-            if (json.choices && Array.isArray(json.choices)) {
-              const choice = json.choices[0];
-              if (choice.message && Array.isArray(choice.message.content)) {
-                const toolUseBlock = choice.message.content.find((block: ToolUseType) => block.type === "tool_use");
-                if (toolUseBlock) {
-                  completeText = schemaStrategy.processResponse(toolUseBlock);
-                  yield completeText;
-                  continue;
-                }
-              }
-
-              // Handle case where the tool use is in the delta
-              if (choice.delta && Array.isArray(choice.delta.content)) {
-                const toolUseBlock = choice.delta.content.find((block: ToolUseType) => block.type === "tool_use");
-                if (toolUseBlock) {
-                  completeText = schemaStrategy.processResponse(toolUseBlock);
-                  yield completeText;
-                  continue;
-                }
-              }
-            }
-          }
-
-          // Extract content from the delta
-          if (json.choices?.[0]?.delta?.content !== undefined) {
-            const content = json.choices[0].delta.content || "";
-
-            // Treat all models the same - yield as content arrives
-            completeText += content;
-            yield schemaStrategy.processResponse(completeText);
-          }
-          // Handle message content format (non-streaming deltas)
-          else if (json.choices?.[0]?.message?.content !== undefined) {
-            const content = json.choices[0].message.content || "";
-            completeText += content;
-            yield schemaStrategy.processResponse(completeText);
-          }
-          // Handle content blocks for Claude/Anthropic response format
-          else if (json.choices?.[0]?.message?.content && Array.isArray(json.choices[0].message.content)) {
-            const contentBlocks = json.choices[0].message.content;
-            // Find text or tool_use blocks
-            for (const block of contentBlocks) {
-              if (block.type === "text") {
-                completeText += block.text || "";
-              } else if (isClaudeWithSchema && block.type === "tool_use") {
-                completeText = schemaStrategy.processResponse(block);
-                break; // We found what we need
-              }
-            }
-
-            yield schemaStrategy.processResponse(completeText);
-          }
-
-          // Find text delta for content blocks (Claude format)
-          if (json.type === "content_block_delta" && json.delta && json.delta.type === "text_delta" && json.delta.text) {
-            if (options.debug) {
-              console.log(`[callAi:${PACKAGE_VERSION}] Received text delta:`, json.delta.text);
-            }
-            completeText += json.delta.text;
-            // In some models like Claude, don't yield partial results as they can be malformed JSON
-            // Only yield what we've seen so far if it's not a Claude model with schema
-            if (!isClaudeWithSchema) {
-              yield schemaStrategy.processResponse(completeText);
-            }
-          }
-        } catch (e) {
-          if (options.debug) {
-            console.error(`[callAIStreaming] Error parsing JSON chunk:`, e);
-          }
-        }
-      }
-    }
-
-    // We no longer need special error handling here as errors are thrown immediately
-
-    // No extra error handling needed here - errors are thrown immediately
-
-    // If we have assembled tool calls but haven't yielded them yet
-    if (toolCallsAssembled && (!completeText || completeText.length === 0)) {
-      // Try to fix any remaining JSON issues before returning
-      let result = toolCallsAssembled;
-
-      try {
-        // Try to parse as-is first
-        JSON.parse(result);
-      } catch (e) {
-        if (options.debug) {
-          console.log(`[callAi:${PACKAGE_VERSION}] Final JSON validation failed:`, e, `\nAttempting to fix JSON:`, result);
-        }
-
-        // Apply more robust fixes for Claude's streaming JSON issues
-
-        // 1. Remove trailing commas (common in malformed JSON)
-        result = result.replace(/,\s*([}\]])/, "$1");
-
-        // 2. Ensure we have proper JSON structure
-        // Add closing braces if missing
-        const openBraces = (result.match(/\{/g) || []).length;
-        const closeBraces = (result.match(/\}/g) || []).length;
-        if (openBraces > closeBraces) {
-          result += "}".repeat(openBraces - closeBraces);
-        }
-
-        // Add opening brace if missing
-        if (!result.trim().startsWith("{")) {
-          result = "{" + result.trim();
-        }
-
-        // Ensure it ends with a closing brace
-        if (!result.trim().endsWith("}")) {
-          result += "}";
-        }
-
-        // Fix dangling property names without values
-        result = result.replace(/"(\w+)"\s*:\s*$/g, '"$1":null');
-
-        // Fix missing property values
-        result = result.replace(/"(\w+)"\s*:\s*,/g, '"$1":null,');
-
-        // Balance brackets
-        const openBrackets = (result.match(/\[/g) || []).length;
-        const closeBrackets = (result.match(/\]/g) || []).length;
-        if (openBrackets > closeBrackets) {
-          result += "]".repeat(openBrackets - closeBrackets);
-        }
-
-        if (options.debug) {
-          console.log(`[callAi:${PACKAGE_VERSION}] Applied final JSON fixes:`, result);
-        }
-      }
-
-      // Return the assembled tool call
-      completeText = result;
-
-      // Try one more time to validate
-      try {
-        JSON.parse(completeText);
-      } catch (finalParseError) {
-        if (options.debug) {
-          console.error(`[callAi:${PACKAGE_VERSION}] Final JSON validation still failed:`, finalParseError);
-        }
-      }
-
-      yield completeText;
-    }
-
-    // Record streaming completion in metadata
-    const endTime = Date.now();
-    meta.timing.endTime = endTime;
-    meta.timing.duration = endTime - meta.timing.startTime;
-
-    // Add the rawResponse field to match non-streaming behavior
-    // For streaming, we use the final complete text as the raw response
-    meta.rawResponse = completeText;
-
-    // Store metadata for this response
-    const boxed = boxString(completeText);
-    responseMetadata.set(boxed, meta);
-
-    // Return the complete text as the final value
-    return completeText;
-  } catch (error) {
-    // Streaming generators must properly handle errors
-    if (options.debug || globalDebug) {
-      console.error(`[callAi:${PACKAGE_VERSION}] Streaming error:`, error);
-    }
-
-    // This error will be caught in the caller's try/catch block
-    throw error;
-  }
-}
-
-// Simplified generator for accessing streaming results
-// Returns an async generator that yields blocks of text
-// This is a higher-level function that prepares the request
-// and handles model fallback
-async function* callAIStreaming(
-  prompt: string | Message[],
-  options: CallAIOptions = {},
-  isRetry = false,
-): AsyncGenerator<string, string, unknown> {
-  // Convert simple string prompts to message array format
-  const messages = Array.isArray(prompt) ? prompt : [{ role: "user", content: prompt } satisfies Message];
-
-  // API key should be provided by options (validation happens in callAi)
-  const apiKey = options.apiKey;
-  const model = options.model || "openai/gpt-3.5-turbo";
-
-  // Default endpoint compatible with OpenAI API
-  const endpoint = options.endpoint || "https://openrouter.ai/api/v1";
-
-  // Build the endpoint URL
-  const url = `${endpoint}/chat/completions`;
-
-  // Choose a schema strategy based on model
-  const schemaStrategy = options.schemaStrategy;
-  if (!schemaStrategy) {
-    throw new Error("Schema strategy is required for streaming");
-  }
-
-  // Default to JSON response for certain models
-  const responseFormat = options.responseFormat || /gpt-4/.test(model) || /gpt-3.5/.test(model) ? "json" : undefined;
-
-  const debug = options.debug === undefined ? globalDebug : options.debug;
-
-  if (debug) {
-    console.log(`[callAi:${PACKAGE_VERSION}] Making streaming request to: ${url}`);
-    console.log(`[callAi:${PACKAGE_VERSION}] With model: ${model}`);
-  }
-
-  // Build request body
-  const requestBody: SchemaAIMessageRequest = {
-    model,
-    messages,
-    max_tokens: options.maxTokens || 2048,
-    temperature: options.temperature !== undefined ? options.temperature : 0.7,
-    top_p: options.topP ? options.topP : 1,
-    stream: true,
-  };
-
-  // Add response_format if specified or for JSON handling
-  if (responseFormat === "json") {
-    requestBody.response_format = { type: "json_object" };
-  }
-
-  // Add schema-specific parameters (if schema is provided)
-  if (options.schema) {
-    Object.assign(requestBody, schemaStrategy?.prepareRequest(options.schema, messages));
-  }
-
-  // Add HTTP referer and other options to help with abuse prevention
-  const headers: Record<string, string> = {
-    Authorization: `Bearer ${apiKey}`,
-    "HTTP-Referer": options.referer || "https://vibes.diy",
-    "X-Title": options.title || "Vibes",
-    "Content-Type": "application/json",
-  };
-
-  // Add any additional headers
-  if (options.headers) {
-    Object.assign(headers, options.headers);
-  }
-
-  // Copy any other options not explicitly handled above
-  Object.keys(options).forEach((key) => {
-    if (
-      ![
-        "apiKey",
-        "model",
-        "endpoint",
-        "stream",
-        "schema",
-        "maxTokens",
-        "temperature",
-        "topP",
-        "responseFormat",
-        "referer",
-        "title",
-        "headers",
-        "skipRefresh",
-        "debug",
-      ].includes(key)
-    ) {
-      requestBody[key] = options[key];
-    }
-  });
-
-  if (debug) {
-    console.log(`[callAi:${PACKAGE_VERSION}] Request headers:`, headers);
-    console.log(`[callAi:${PACKAGE_VERSION}] Request body:`, requestBody);
-  }
-
-  let response;
-  try {
-    // Make the API request
-    response = await callAiFetch(options)(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(requestBody),
-    });
-
-    // Handle HTTP errors
-    if (!response.ok) {
-      // Check if this is an invalid model error that we can handle with a fallback
-      const { isInvalidModel, errorData } = await checkForInvalidModelError(response, model, debug);
-
-      if (isInvalidModel && !isRetry && !options.skipRetry) {
-        if (debug) {
-          console.log(`[callAi:${PACKAGE_VERSION}] Invalid model "${model}", falling back to "${FALLBACK_MODEL}"`);
-        }
-
-        // Retry with the fallback model using yield* to delegate to the other generator
-        yield* callAIStreaming(
-          prompt,
-          {
-            ...options,
-            model: FALLBACK_MODEL,
-          },
-          true, // Mark as retry to prevent infinite fallback loops
-        );
-
-        // Generator delegation handles returning the final value
-        return "";
-      }
-
-      // For other errors, throw with details
-      const errorText = errorData ? JSON.stringify(errorData) : `HTTP error! Status: ${response.status}`;
-      throw new Error(errorText);
-    }
-
-    // Yield streaming results through the generator
-    yield* createStreamingGenerator(response, options, schemaStrategy, model);
-
-    // The createStreamingGenerator will return the final assembled string
-    return ""; // This is never reached due to yield*
-  } catch (fetchError) {
-    // Network errors must be directly re-thrown without modification
-    // This is exactly how the original implementation handles it
-    if (debug) {
-      console.error(`[callAi:${PACKAGE_VERSION}] Network error during fetch:`, fetchError);
-    }
-    // Critical: throw the exact same error object without any wrapping
-    throw fetchError;
-  }
-}
-
-export { createStreamingGenerator, callAIStreaming };