AiProvider.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2026 Gunter Königsmann <wxMaxima@physikbuch.de>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
//  SPDX-License-Identifier: GPL-2.0+
 
#ifndef AIPROVIDER_H
#define AIPROVIDER_H
 
#include "precomp.h"
#include <wx/wx.h>
#include <functional>
#include <memory>
#include <vector>
 
struct AiChatMessage {
  wxString role;
  wxString content;
};
 
enum class AiProviderKind {
  None = 0, Anthropic = 1, OpenAI = 2, Google = 3, Qwen = 4, Custom = 5, GitHubModels = 6,
  DeepSeek = 7, OpenRouter = 8
};
 
enum class AiProviderShape { Anthropic, OpenAiCompatible, Google };
 
wxString AiProviderShapeName(AiProviderShape shape);
 
int AiProviderShapeToChoiceIndex(AiProviderShape shape);
AiProviderShape AiProviderShapeFromChoiceIndex(int index);
 
wxString AiProviderRequestUrlProblem(const wxString &url);
 
struct AiCustomProviderConfig {
  wxString id;
  wxString name;
  AiProviderShape shape = AiProviderShape::OpenAiCompatible;
  wxString baseUrl;
  wxString model;
  wxString username;
};
 
struct AiLocalServerPreset {
  wxString name;
  wxString baseUrl;
  wxString model;
};
 
std::vector<AiLocalServerPreset> AiKnownLocalServerPresets();
 
wxString NewAiCustomProviderId();
 
std::vector<AiCustomProviderConfig> ParseAiCustomProviders(const wxString &json);
 
wxString SerializeAiCustomProviders(const std::vector<AiCustomProviderConfig> &providers);
 
wxString AiProviderKindName(AiProviderKind kind);
 
wxString AiProviderDefaultModel(AiProviderKind kind);
 
wxString AiProviderApiKeyUrl(AiProviderKind kind);
 
wxString AiProviderBaseUrl(AiProviderKind kind);
 
wxString AiProviderModelListUrl(AiProviderKind kind);
 
using AiRequestCanceller = std::function<void()>;
 
class AiProvider {
public:
  AiProvider(wxString baseUrl, wxString apiKey, wxString model)
    : m_baseUrl(std::move(baseUrl)), m_apiKey(std::move(apiKey)),
      m_model(std::move(model)) {}
  virtual ~AiProvider() = default;
 
  virtual AiProviderKind Kind() const = 0;
  wxString Name() const {
    return m_displayName.IsEmpty() ? AiProviderKindName(Kind()) : m_displayName;
  }
  void SetDisplayName(const wxString &name) { m_displayName = name; }
 
  void SetBasicAuthUser(const wxString &user) { m_basicAuthUser = user; }
 
  static bool SecretStoreAvailable();
 
  static void SaveApiKey(const wxString &service, const wxString &apiKey);
  static wxString LoadApiKey(const wxString &service);
  static void DeleteApiKey(const wxString &service);
  static wxString CustomProviderSecretService(const wxString &id);
  static wxString BuiltinProviderSecretService(AiProviderKind kind);
 
  virtual wxString RequestUrl() const { return m_baseUrl; }
 
  virtual std::vector<std::pair<wxString, wxString>> AuthHeaders() const = 0;
 
  virtual wxString BuildRequestBody(const wxString &context,
                                    const std::vector<AiChatMessage> &history) const = 0;
 
  virtual wxString ParseReply(const wxString &responseBody) const = 0;
 
  static AiRequestCanceller
  SendChat(std::shared_ptr<const AiProvider> self, wxEvtHandler *owner,
           const wxString &context,
           const std::vector<AiChatMessage> &history,
           std::function<void(bool ok, const wxString &replyOrError)> callback,
           std::function<void(const wxString &requestBody)> onRequest = nullptr,
           std::function<void(bool ok, const wxString &responseBodyOrDetail)> onResponse = nullptr);
 
  virtual wxString ModelsRequestUrl() const;
 
  virtual std::vector<wxString> ParseModelList(const wxString &responseBody) const;
 
  static void FetchModels(std::shared_ptr<const AiProvider> self, wxEvtHandler *owner,
                          std::function<void(bool ok, const std::vector<wxString> &models,
                                             const wxString &errorIfAny)> callback);
 
  static bool NetworkingAvailable();
 
protected:
  bool UsesBasicAuth() const { return !m_basicAuthUser.IsEmpty(); }
  std::pair<wxString, wxString> BasicAuthHeader() const;
 
  wxString m_baseUrl;
  wxString m_apiKey;
  wxString m_model;
  wxString m_displayName;
  wxString m_basicAuthUser;
};
 
class AiProviderError : public std::runtime_error {
public:
  explicit AiProviderError(const std::string &msg) : std::runtime_error(msg) {}
};
 
std::shared_ptr<AiProvider> MakeAiProvider(AiProviderKind kind, const wxString &apiKey,
                                           const wxString &model);
 
std::shared_ptr<AiProvider> MakeAiProviderForShape(AiProviderShape shape,
                                                   const wxString &displayName,
                                                   const wxString &baseUrl,
                                                   const wxString &apiKey,
                                                   const wxString &model,
                                                   const wxString &basicAuthUser = wxEmptyString);
 
#endif // AIPROVIDER_H