@happyvertical/ai 0.79.0 → 0.80.1

package/dist/chunks/gemini-CS56gY0D.js

@@ -1,768 +0,0 @@
-import crypto from "node:crypto";
-import { b as normalizeBaseAIOptions, A as AIError, n as normalizeChatOptions, p as prepareRequestControls, a as normalizeImageGenerationOptions, f as extractTextContent, d as AuthenticationError, R as RateLimitError, e as extractRetryAfterSeconds, M as ModelNotFoundError } from "./index-DCXO0nZA.js";
-import { e as emitUsage } from "./usage-DMWiJ2oB.js";
-class GeminiProvider {
-  options;
-  client;
-  // GoogleGenAI instance from @google/genai
-  constructor(options) {
-    this.options = normalizeBaseAIOptions({
-      defaultModel: "gemini-2.5-flash",
-      ...options
-    });
-    this.initializeClientSync();
-  }
-  initializeClientSync() {
-    try {
-      import("@google/genai").then(({ GoogleGenAI }) => {
-        this.client = new GoogleGenAI(this.buildClientConfig());
-      }).catch(() => {
-      });
-    } catch (_error) {
-    }
-  }
-  async ensureClient() {
-    if (!this.client) {
-      try {
-        const { GoogleGenAI } = await import("@google/genai");
-        this.client = new GoogleGenAI(this.buildClientConfig());
-      } catch (_error) {
-        throw new AIError(
-          "Failed to initialize Gemini client. Make sure @google/genai is installed.",
-          "INITIALIZATION_ERROR",
-          "gemini"
-        );
-      }
-    }
-  }
-  /**
-   * Build the GoogleGenAI client configuration based on provided options.
-   * Supports both Google AI Studio (apiKey only) and Vertex AI (projectId + location).
-   */
-  buildClientConfig() {
-    if (this.options.projectId && this.options.location) {
-      return {
-        vertexai: true,
-        project: this.options.projectId,
-        location: this.options.location,
-        apiKey: this.options.apiKey,
-        // Optional for Vertex AI with ADC
-        httpOptions: {
-          timeout: this.options.timeout,
-          retryOptions: { attempts: (this.options.maxRetries || 0) + 1 }
-        }
-      };
-    }
-    return {
-      apiKey: this.options.apiKey,
-      httpOptions: {
-        timeout: this.options.timeout,
-        retryOptions: { attempts: (this.options.maxRetries || 0) + 1 }
-      }
-    };
-  }
-  async chat(messages, options = {}) {
-    const startTime = Date.now();
-    let controls;
-    try {
-      await this.ensureClient();
-      const model = options.model || this.options.defaultModel;
-      options = normalizeChatOptions(this.options, options, "gemini", model);
-      controls = prepareRequestControls(this.options, options);
-      const requestConfig = {
-        model,
-        contents: this.messagesToGeminiFormat(messages),
-        config: this.buildGenerateContentConfig(options, controls)
-      };
-      const result = await this.client.models.generateContent(requestConfig);
-      let toolCalls;
-      const firstCandidate = result.candidates?.[0];
-      if (firstCandidate?.content?.parts) {
-        const functionCalls = firstCandidate.content.parts.filter(
-          (part) => part.functionCall
-        );
-        if (functionCalls.length > 0) {
-          toolCalls = functionCalls.map((part) => ({
-            id: `call_${crypto.randomUUID()}`,
-            type: "function",
-            function: {
-              name: part.functionCall.name,
-              arguments: JSON.stringify(part.functionCall.args || {})
-            }
-          }));
-        }
-      }
-      let content = result.text || "";
-      if (options.responseFormat?.type === "json_object") {
-        content = this.stripMarkdownCodeBlock(content);
-      }
-      const usage = {
-        promptTokens: result.usageMetadata?.promptTokenCount || 0,
-        completionTokens: result.usageMetadata?.candidatesTokenCount || 0,
-        totalTokens: result.usageMetadata?.totalTokenCount || 0
-      };
-      emitUsage(
-        this.options,
-        "gemini",
-        "chat",
-        model,
-        usage,
-        startTime,
-        options.usageTags
-      );
-      return {
-        content,
-        model,
-        finishReason: this.mapFinishReason(result),
-        usage,
-        toolCalls: toolCalls && toolCalls.length > 0 ? toolCalls : void 0
-      };
-    } catch (error) {
-      if (controls?.didTimeout()) {
-        throw new AIError(
-          `AI request timed out after ${controls.timeout}ms`,
-          "AI_TIMEOUT",
-          "gemini",
-          options.model
-        );
-      }
-      if (options.signal?.aborted) {
-        throw new AIError(
-          "AI request aborted by caller",
-          "AI_ABORTED",
-          "gemini",
-          options.model
-        );
-      }
-      throw this.mapError(error);
-    } finally {
-      controls?.cleanup();
-    }
-  }
-  async complete(prompt, options = {}) {
-    return this.chat([{ role: "user", content: prompt }], {
-      model: options.model,
-      maxTokens: options.maxTokens,
-      temperature: options.temperature,
-      topP: options.topP,
-      n: options.n,
-      stop: options.stop,
-      stream: options.stream,
-      onProgress: options.onProgress,
-      signal: options.signal,
-      timeout: options.timeout,
-      reasoning: options.reasoning,
-      usageTags: options.usageTags
-    });
-  }
-  /**
-   * Simple message interface for single-turn interactions with optional history
-   *
-   * @param text - The message text to send
-   * @param options - Configuration options including history, model, etc.
-   * @returns Promise resolving to the response content string
-   *
-   * @example
-   * ```typescript
-   * // Simple usage
-   * const response = await provider.message('Hello!');
-   *
-   * // With history
-   * const response = await provider.message('What was my question?', {
-   *   history: [
-   *     { role: 'user', content: 'What is 2+2?' },
-   *     { role: 'assistant', content: '4' }
-   *   ]
-   * });
-   * ```
-   */
-  async message(text, options = {}) {
-    const messages = [
-      ...options.history || [],
-      { role: options.role || "user", content: text }
-    ];
-    const response = await this.chat(messages, {
-      model: options.model,
-      maxTokens: options.maxTokens,
-      temperature: options.temperature,
-      topP: options.topP,
-      stop: options.stop,
-      stream: options.stream,
-      frequencyPenalty: options.frequencyPenalty,
-      presencePenalty: options.presencePenalty,
-      responseFormat: options.responseFormat,
-      seed: options.seed,
-      tools: options.tools,
-      toolChoice: options.toolChoice,
-      onProgress: options.onProgress,
-      signal: options.signal,
-      timeout: options.timeout,
-      reasoning: options.reasoning,
-      usageTags: options.usageTags
-    });
-    return response.content;
-  }
-  /**
-   * Generate embeddings for text using Gemini embedding models
-   * @param text - Single text string or array of texts to embed
-   * @param options - Optional configuration for embeddings
-   * @returns Promise resolving to embeddings response
-   *
-   * @example
-   * ```typescript
-   * const embedding = await provider.embed('Hello world');
-   * const embeddings = await provider.embed(['Text 1', 'Text 2']);
-   * ```
-   */
-  async embed(text, options = {}) {
-    const startTime = Date.now();
-    try {
-      await this.ensureClient();
-      const model = options.model || "text-embedding-004";
-      const input = Array.isArray(text) ? text : [text];
-      const embeddings = [];
-      let totalTokens = 0;
-      for (const content of input) {
-        const config = {};
-        if (options.dimensions) {
-          config.outputDimensionality = options.dimensions;
-        }
-        const result = await this.client.models.embedContent({
-          model,
-          contents: content,
-          config: Object.keys(config).length > 0 ? config : void 0
-        });
-        if (result.embeddings?.[0]?.values) {
-          embeddings.push(result.embeddings[0].values);
-        }
-        if (result.metadata?.tokenCount) {
-          totalTokens += result.metadata.tokenCount;
-        }
-      }
-      const usage = totalTokens > 0 ? {
-        promptTokens: totalTokens,
-        completionTokens: 0,
-        totalTokens
-      } : void 0;
-      emitUsage(
-        this.options,
-        "gemini",
-        "embed",
-        model,
-        usage,
-        startTime,
-        options.usageTags
-      );
-      return {
-        embeddings,
-        model,
-        usage
-      };
-    } catch (error) {
-      throw this.mapError(error);
-    }
-  }
-  /**
-   * Convert an image to Gemini inline format
-   * @param image - Image as URL, base64 data URL, or Buffer
-   * @returns Gemini inline data format
-   * @private
-   */
-  async imageToGeminiFormat(image, signal) {
-    let mimeType = "image/png";
-    let base64Data;
-    if (Buffer.isBuffer(image)) {
-      base64Data = image.toString("base64");
-    } else if (image.startsWith("data:")) {
-      const match = image.match(/^data:([^;]+);base64,(.+)$/);
-      if (match) {
-        mimeType = match[1];
-        base64Data = match[2];
-      } else {
-        throw new AIError(
-          "Invalid base64 data URL format",
-          "INVALID_INPUT",
-          "gemini"
-        );
-      }
-    } else {
-      const response = await fetch(image, { signal });
-      if (!response.ok) {
-        throw new AIError(
-          `Failed to fetch image: ${response.status} ${response.statusText}`,
-          "IMAGE_FETCH_ERROR",
-          "gemini"
-        );
-      }
-      const arrayBuffer = await response.arrayBuffer();
-      base64Data = Buffer.from(arrayBuffer).toString("base64");
-      mimeType = response.headers.get("content-type") || "image/png";
-    }
-    return {
-      inlineData: { mimeType, data: base64Data }
-    };
-  }
-  /**
-   * Generate a text description of an image
-   * @param image - Image as URL, base64 data URL, or Buffer
-   * @param prompt - Custom prompt for description (optional)
-   * @param options - Optional configuration
-   * @returns Promise resolving to the description string
-   *
-   * @example
-   * ```typescript
-   * const description = await provider.describeImage('https://example.com/image.jpg');
-   * ```
-   */
-  async describeImage(image, prompt, options = {}) {
-    let controls;
-    try {
-      await this.ensureClient();
-      const defaultPrompt = "Describe this image for a search index. Include objects, mood, lighting, and any visible text.";
-      const model = options.model || this.options.defaultModel || "gemini-2.5-flash";
-      const normalized = normalizeChatOptions(
-        this.options,
-        { ...options, maxTokens: options.maxTokens ?? 500 },
-        "gemini",
-        model
-      );
-      controls = prepareRequestControls(this.options, normalized);
-      const imageData = await this.imageToGeminiFormat(image, controls.signal);
-      const response = await this.client.models.generateContent({
-        model,
-        contents: [{ text: prompt || defaultPrompt }, imageData],
-        config: this.buildGenerateContentConfig(normalized, controls)
-      });
-      return response.text || "";
-    } catch (error) {
-      if (controls?.didTimeout()) {
-        throw new AIError(
-          `AI request timed out after ${controls.timeout}ms`,
-          "AI_TIMEOUT",
-          "gemini",
-          options.model
-        );
-      }
-      if (options.signal?.aborted) {
-        throw new AIError(
-          "AI request aborted by caller",
-          "AI_ABORTED",
-          "gemini",
-          options.model
-        );
-      }
-      throw this.mapError(error);
-    } finally {
-      controls?.cleanup();
-    }
-  }
-  /**
-   * Generate embeddings for an image using native multimodal embeddings
-   * @param image - Image as URL, base64 data URL, or Buffer
-   * @param options - Optional configuration for image embeddings
-   * @returns Promise resolving to embeddings response
-   *
-   * @example
-   * ```typescript
-   * const embedding = await provider.embedImage('https://example.com/image.jpg');
-   * ```
-   */
-  async embedImage(image, options = {}) {
-    try {
-      await this.ensureClient();
-      const model = options.model || "multimodalembedding@001";
-      const imageData = await this.imageToGeminiFormat(image);
-      const config = {};
-      if (options.dimensions) {
-        config.outputDimensionality = options.dimensions;
-      }
-      const result = await this.client.models.embedContent({
-        model,
-        contents: [imageData],
-        config: Object.keys(config).length > 0 ? config : void 0
-      });
-      return {
-        embeddings: result.embeddings?.[0]?.values ? [result.embeddings[0].values] : [],
-        model
-      };
-    } catch (error) {
-      throw this.mapError(error);
-    }
-  }
-  /**
-   * Generate an image from a text prompt using Imagen 3
-   * @param prompt - Text description of the image to generate
-   * @param options - Optional configuration for image generation
-   * @returns Promise resolving to generated image(s)
-   *
-   * @example
-   * ```typescript
-   * const result = await provider.generateImage('A sunset over mountains');
-   * fs.writeFileSync('image.png', result.images[0].data);
-   * ```
-   */
-  async generateImage(prompt, options = {}) {
-    let controls;
-    try {
-      await this.ensureClient();
-      const model = options.model || "imagen-3.0-generate-002";
-      options = normalizeImageGenerationOptions(
-        this.options,
-        options,
-        "gemini",
-        model
-      );
-      controls = prepareRequestControls(this.options, options);
-      const config = {
-        numberOfImages: options.n,
-        abortSignal: controls.signal,
-        httpOptions: {
-          timeout: controls.timeout,
-          retryOptions: { attempts: (this.options.maxRetries || 0) + 1 }
-        }
-      };
-      if (options.aspectRatio) {
-        config.aspectRatio = options.aspectRatio;
-      }
-      const response = await this.client.models.generateImages({
-        model,
-        prompt,
-        config
-      });
-      const images = (response.generatedImages || []).map((img) => {
-        let data;
-        const mimeType = "image/png";
-        const imageBytes = img.image?.imageBytes;
-        if (options.outputFormat === "base64") {
-          data = typeof imageBytes === "string" ? imageBytes : Buffer.from(imageBytes).toString("base64");
-        } else if (options.outputFormat === "url") {
-          const b64 = typeof imageBytes === "string" ? imageBytes : Buffer.from(imageBytes).toString("base64");
-          data = `data:${mimeType};base64,${b64}`;
-        } else {
-          data = typeof imageBytes === "string" ? Buffer.from(imageBytes, "base64") : Buffer.from(imageBytes);
-        }
-        return {
-          data,
-          mimeType
-        };
-      });
-      return {
-        images,
-        model
-      };
-    } catch (error) {
-      if (controls?.didTimeout()) {
-        throw new AIError(
-          `AI request timed out after ${controls.timeout}ms`,
-          "AI_TIMEOUT",
-          "gemini",
-          options.model
-        );
-      }
-      if (options.signal?.aborted) {
-        throw new AIError(
-          "AI request aborted by caller",
-          "AI_ABORTED",
-          "gemini",
-          options.model
-        );
-      }
-      throw this.mapError(error);
-    } finally {
-      controls?.cleanup();
-    }
-  }
-  async *stream(messages, options = {}) {
-    const startTime = Date.now();
-    let controls;
-    try {
-      await this.ensureClient();
-      const model = options.model || this.options.defaultModel;
-      options = normalizeChatOptions(this.options, options, "gemini", model);
-      controls = prepareRequestControls(this.options, options);
-      const stream = await this.client.models.generateContentStream({
-        model,
-        contents: this.messagesToGeminiFormat(messages),
-        config: this.buildGenerateContentConfig(options, controls)
-      });
-      let usage;
-      for await (const chunk of stream) {
-        if (chunk.usageMetadata) {
-          usage = {
-            promptTokens: chunk.usageMetadata.promptTokenCount || 0,
-            completionTokens: chunk.usageMetadata.candidatesTokenCount || 0,
-            totalTokens: chunk.usageMetadata.totalTokenCount || 0
-          };
-        }
-        const text = chunk.text || "";
-        if (!text) {
-          continue;
-        }
-        if (options.onProgress) {
-          options.onProgress(text);
-        }
-        yield text;
-      }
-      emitUsage(
-        this.options,
-        "gemini",
-        "stream",
-        model,
-        usage,
-        startTime,
-        options.usageTags
-      );
-    } catch (error) {
-      if (controls?.didTimeout()) {
-        throw new AIError(
-          `AI request timed out after ${controls.timeout}ms`,
-          "AI_TIMEOUT",
-          "gemini",
-          options.model
-        );
-      }
-      if (options.signal?.aborted) {
-        throw new AIError(
-          "AI request aborted by caller",
-          "AI_ABORTED",
-          "gemini",
-          options.model
-        );
-      }
-      throw this.mapError(error);
-    } finally {
-      controls?.cleanup();
-    }
-  }
-  async countTokens(text) {
-    try {
-      await this.ensureClient();
-      const model = this.options.defaultModel || "gemini-2.5-flash";
-      const response = await this.client.models.countTokens({
-        model,
-        contents: text
-      });
-      return response.totalTokens || Math.ceil(text.length / 4);
-    } catch (error) {
-      throw this.mapError(error);
-    }
-  }
-  async getModels() {
-    return [
-      {
-        id: "gemini-3-flash-preview",
-        name: "Gemini 3 Flash Preview",
-        description: "Preview of Gemini 3 Flash model. Available on Vertex AI in us-central1 only.",
-        contextLength: 1e6,
-        capabilities: ["text", "chat", "vision", "functions"],
-        supportsFunctions: true,
-        supportsVision: true
-      },
-      {
-        id: "gemini-2.0-flash-001",
-        name: "Gemini 2.0 Flash",
-        description: "Latest fast and efficient Gemini model with function calling",
-        contextLength: 1e6,
-        capabilities: ["text", "chat", "vision", "functions"],
-        supportsFunctions: true,
-        supportsVision: true
-      },
-      {
-        id: "gemini-2.5-flash",
-        name: "Gemini 2.5 Flash",
-        description: "Experimental next-generation Gemini model",
-        contextLength: 1e6,
-        capabilities: ["text", "chat", "vision", "functions"],
-        supportsFunctions: true,
-        supportsVision: true
-      },
-      {
-        id: "gemini-1.5-pro",
-        name: "Gemini 1.5 Pro (Legacy)",
-        description: "Previous generation model (may not be available)",
-        contextLength: 2e6,
-        capabilities: ["text", "chat", "vision", "functions"],
-        supportsFunctions: true,
-        supportsVision: true
-      }
-    ];
-  }
-  async getCapabilities() {
-    return {
-      chat: true,
-      completion: true,
-      embeddings: true,
-      streaming: true,
-      functions: true,
-      vision: true,
-      fineTuning: false,
-      imageEmbeddings: true,
-      imageGeneration: true,
-      tts: false,
-      voiceCloning: false,
-      voiceDesign: false,
-      maxContextLength: 2e6,
-      supportedOperations: [
-        "chat",
-        "completion",
-        "embedding",
-        "streaming",
-        "functions",
-        "vision",
-        "image_embedding",
-        "image_generation"
-      ]
-    };
-  }
-  // ============================================================================
-  // TTS Methods (Not supported - use Qwen3-TTS provider)
-  // ============================================================================
-  async synthesizeSpeech(_text, _options) {
-    throw new AIError(
-      "TTS is not supported by Gemini provider. Use Qwen3-TTS provider.",
-      "NOT_IMPLEMENTED",
-      "gemini"
-    );
-  }
-  streamSpeech(_text, _options) {
-    const error = new AIError(
-      "TTS streaming is not supported by Gemini provider. Use Qwen3-TTS provider.",
-      "NOT_IMPLEMENTED",
-      "gemini"
-    );
-    return {
-      [Symbol.asyncIterator]: () => ({
-        next: () => Promise.reject(error)
-      })
-    };
-  }
-  async cloneVoice(_options) {
-    throw new AIError(
-      "Voice cloning is not supported by Gemini provider. Use Qwen3-TTS provider.",
-      "NOT_IMPLEMENTED",
-      "gemini"
-    );
-  }
-  async designVoice(_options) {
-    throw new AIError(
-      "Voice design is not supported by Gemini provider. Use Qwen3-TTS provider.",
-      "NOT_IMPLEMENTED",
-      "gemini"
-    );
-  }
-  async getVoices(_options) {
-    throw new AIError(
-      "Voice listing is not supported by Gemini provider. Use Qwen3-TTS provider.",
-      "NOT_IMPLEMENTED",
-      "gemini"
-    );
-  }
-  mapToolChoice(toolChoice) {
-    if (!toolChoice || toolChoice === "auto") {
-      return { functionCallingConfig: { mode: "AUTO" } };
-    }
-    if (toolChoice === "none") {
-      return { functionCallingConfig: { mode: "NONE" } };
-    }
-    if (typeof toolChoice === "object" && toolChoice.type === "function") {
-      return {
-        functionCallingConfig: {
-          mode: "ANY",
-          allowedFunctionNames: [toolChoice.function.name]
-        }
-      };
-    }
-    return { functionCallingConfig: { mode: "AUTO" } };
-  }
-  buildGenerateContentConfig(options, controls) {
-    const config = {
-      abortSignal: controls.signal,
-      httpOptions: {
-        timeout: controls.timeout,
-        retryOptions: { attempts: (this.options.maxRetries || 0) + 1 }
-      },
-      maxOutputTokens: options.maxTokens,
-      temperature: options.temperature,
-      topP: options.topP,
-      stopSequences: Array.isArray(options.stop) ? options.stop : options.stop ? [options.stop] : void 0,
-      responseMimeType: options.responseFormat?.type === "json_object" ? "application/json" : void 0,
-      frequencyPenalty: options.frequencyPenalty,
-      presencePenalty: options.presencePenalty,
-      seed: options.seed
-    };
-    if (options.tools && options.tools.length > 0) {
-      config.tools = [
-        {
-          functionDeclarations: options.tools.map((tool) => ({
-            name: tool.function.name,
-            description: tool.function.description || "",
-            parameters: tool.function.parameters || { type: "object" }
-          }))
-        }
-      ];
-      config.toolConfig = this.mapToolChoice(options.toolChoice);
-    }
-    const reasoning = options.reasoning;
-    if (reasoning?.maxTokens !== void 0 && reasoning.maxTokens > 0) {
-      config.thinkingConfig = {
-        thinkingBudget: reasoning.maxTokens,
-        includeThoughts: reasoning.includeThoughts
-      };
-    }
-    return Object.fromEntries(
-      Object.entries(config).filter(([, value]) => value !== void 0)
-    );
-  }
-  mapFinishReason(response) {
-    const firstCandidate = response.candidates?.[0];
-    if (firstCandidate?.content?.parts) {
-      const hasFunctionCall = firstCandidate.content.parts.some(
-        (part) => part.functionCall
-      );
-      if (hasFunctionCall) {
-        return "tool_calls";
-      }
-    }
-    return "stop";
-  }
-  messagesToGeminiFormat(messages) {
-    return messages.map((message) => {
-      const textContent = extractTextContent(message.content);
-      switch (message.role) {
-        case "system":
-          return `Instructions: ${textContent}`;
-        case "user":
-          return `Human: ${textContent}`;
-        case "assistant":
-          return `Assistant: ${textContent}`;
-        default:
-          return textContent;
-      }
-    }).join("\n\n");
-  }
-  stripMarkdownCodeBlock(text) {
-    const codeBlockRegex = /^```(?:json|javascript|typescript)?\s*\n?([\s\S]*?)\n?```\s*$/;
-    const match = text.match(codeBlockRegex);
-    return match ? match[1].trim() : text.trim();
-  }
-  mapError(error) {
-    if (error instanceof AIError) {
-      return error;
-    }
-    const message = error instanceof Error ? error.message : "Unknown Gemini error occurred";
-    if (message.includes("API_KEY_INVALID") || message.includes("401")) {
-      return new AuthenticationError("gemini");
-    }
-    if (message.includes("QUOTA_EXCEEDED") || message.includes("429")) {
-      return new RateLimitError("gemini", extractRetryAfterSeconds(error));
-    }
-    if (message.includes("MODEL_NOT_FOUND") || message.includes("404")) {
-      return new ModelNotFoundError(message, "gemini");
-    }
-    return new AIError(message, "UNKNOWN_ERROR", "gemini");
-  }
-}
-export {
-  GeminiProvider
-};
-//# sourceMappingURL=gemini-CS56gY0D.js.map