@happyvertical/ai 0.74.8

package/dist/chunks/gemini-BfpHXDIQ.js

@@ -0,0 +1,662 @@
+import crypto from "node:crypto";
+import { A as AIError, c as extractTextContent, b as AuthenticationError, R as RateLimitError, e as extractRetryAfterSeconds, M as ModelNotFoundError } from "./index-BT4thAvS.js";
+import { e as emitUsage } from "./usage-DMWiJ2oB.js";
+class GeminiProvider {
+  options;
+  client;
+  // GoogleGenAI instance from @google/genai
+  constructor(options) {
+    this.options = {
+      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
+      };
+    }
+    return {
+      apiKey: this.options.apiKey
+    };
+  }
+  async chat(messages, options = {}) {
+    const startTime = Date.now();
+    try {
+      await this.ensureClient();
+      const model = options.model || this.options.defaultModel;
+      const requestConfig = {
+        model,
+        contents: this.messagesToGeminiFormat(messages),
+        config: this.buildGenerateContentConfig(options)
+      };
+      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) {
+      throw this.mapError(error);
+    }
+  }
+  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,
+      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,
+      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) {
+    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);
+      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 = {}) {
+    try {
+      await this.ensureClient();
+      const defaultPrompt = "Describe this image for a search index. Include objects, mood, lighting, and any visible text.";
+      const imageData = await this.imageToGeminiFormat(image);
+      const response = await this.client.models.generateContent({
+        model: options.model || this.options.defaultModel || "gemini-2.5-flash",
+        contents: [{ text: prompt || defaultPrompt }, imageData],
+        config: {
+          maxOutputTokens: options.maxTokens || 500
+        }
+      });
+      return response.text || "";
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * 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 = {}) {
+    try {
+      await this.ensureClient();
+      const model = options.model || "imagen-3.0-generate-002";
+      const config = {
+        numberOfImages: options.n || 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) {
+      throw this.mapError(error);
+    }
+  }
+  async *stream(messages, options = {}) {
+    const startTime = Date.now();
+    try {
+      await this.ensureClient();
+      const model = options.model || this.options.defaultModel;
+      const stream = await this.client.models.generateContentStream({
+        model,
+        contents: this.messagesToGeminiFormat(messages),
+        config: this.buildGenerateContentConfig(options)
+      });
+      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) {
+      throw this.mapError(error);
+    }
+  }
+  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" } };
+  }
+  /**
+   * Map thinking level from our type to SDK's expected format
+   * The SDK expects uppercase values: MINIMAL, LOW, MEDIUM, HIGH
+   */
+  mapThinkingLevel(level) {
+    return level.toUpperCase();
+  }
+  buildGenerateContentConfig(options) {
+    const config = {
+      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 thinkingLevel = options.thinkingLevel || this.options.thinkingLevel;
+    if (thinkingLevel || options.includeThoughts !== void 0) {
+      config.thinkingConfig = {
+        ...thinkingLevel && {
+          thinkingLevel: this.mapThinkingLevel(thinkingLevel)
+        },
+        ...options.includeThoughts !== void 0 && {
+          includeThoughts: options.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-BfpHXDIQ.js.map