browser_ai_service.h

Go to the documentation of this file.

#ifndef YAZE_SRC_CLI_SERVICE_AI_BROWSER_AI_SERVICE_H_
#define YAZE_SRC_CLI_SERVICE_AI_BROWSER_AI_SERVICE_H_
 
#ifdef __EMSCRIPTEN__
 
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/net/http_client.h"
#include "cli/service/ai/ai_service.h"
#include "cli/service/ai/common.h"
#include "nlohmann/json.hpp"
 
namespace yaze {
 
class Rom;
 
namespace cli {
 
namespace agent {
struct ChatMessage;
}
 
struct BrowserAIConfig {
  // Provider selector: "gemini" (default) or "openai"
  std::string provider = "gemini";
 
  // API keys (provider-specific)
  std::string api_key;  // Gemini/OpenAI API key
  std::string model = "gemini-2.5-flash";  // Default to latest flash model
 
  // Optional custom endpoints (leave empty for defaults)
  std::string api_base;  // e.g., "https://api.openai.com/v1"
 
  float temperature = 0.7f;
  int max_output_tokens = 2048;
  std::string system_instruction;  // System prompt
  bool verbose = false;            // Enable debug logging
  int timeout_seconds = 30;        // Request timeout
};
 
class BrowserAIService : public AIService {
 public:
  explicit BrowserAIService(const BrowserAIConfig& config,
                             std::unique_ptr<net::IHttpClient> http_client);
 
  ~BrowserAIService() override = default;
 
  void SetRomContext(Rom* rom) override;
 
  absl::StatusOr<AgentResponse> GenerateResponse(
      const std::string& prompt) override;
 
  absl::StatusOr<AgentResponse> GenerateResponse(
      const std::vector<agent::ChatMessage>& history) override;
 
  absl::StatusOr<std::vector<ModelInfo>> ListAvailableModels() override;
 
  std::string GetProviderName() const override { return config_.provider; }
 
  absl::StatusOr<AgentResponse> AnalyzeImage(const std::string& image_data,
                                              const std::string& prompt);
 
  absl::Status CheckAvailability();
 
  void UpdateApiKey(const std::string& api_key);
 
 private:
  bool RequiresApiKey() const;
  std::string GetOpenAIApiBase() const;
 
  std::string BuildApiUrl(const std::string& endpoint) const;
 
  std::string BuildRequestBody(const std::string& prompt,
                               bool include_system = true) const;
 
  std::string BuildMultimodalRequestBody(const std::string& prompt,
                                         const std::string& image_data,
                                         const std::string& mime_type) const;
 
  std::string BuildOpenAIRequestBody(
      const std::string& prompt,
      const std::vector<agent::ChatMessage>* history = nullptr) const;
 
  absl::StatusOr<AgentResponse> ParseGeminiResponse(
      const std::string& response_body) const;
 
  absl::StatusOr<AgentResponse> ParseOpenAIResponse(
      const std::string& response_body) const;
 
  std::string ExtractTextFromCandidates(const nlohmann::json& json) const;
 
  absl::Status CheckForApiError(const nlohmann::json& json) const;
 
  void LogDebug(const std::string& message) const;
 
  // Configuration
  BrowserAIConfig config_;
 
  // HTTP client for API requests
  std::unique_ptr<net::IHttpClient> http_client_;
 
  // ROM context (not owned)
  Rom* rom_ = nullptr;
 
  // Gemini API base URL
  static constexpr const char* kGeminiApiBaseUrl =
      "https://generativelanguage.googleapis.com/v1beta/models/";
  static constexpr const char* kOpenAIApiBaseUrl =
      "https://api.openai.com/v1";
 
  // Mutex for thread safety
  mutable std::mutex mutex_;
};
 
}  // namespace cli
}  // namespace yaze
 
#endif  // __EMSCRIPTEN__
 
#endif  // YAZE_SRC_CLI_SERVICE_AI_BROWSER_AI_SERVICE_H_