feat: [Ai] Adapt the existing AI capabilities to switch between multi…

src/base/ai/abstractllm.cpp

@@ -9,3 +9,17 @@ AbstractLLM::AbstractLLM(QObject *parent)
 {
     qRegisterMetaType<ResponseState>("ResponseState");
 }
+
+void AbstractLLM::setModelState(LLMState st)
+{
+    if (state.loadAcquire() == st)
+        return;
+
+    state.storeRelease(st);
+    Q_EMIT modelStateChanged();
+}
+
+AbstractLLM::LLMState AbstractLLM::modelState() const
+{
+    return static_cast<LLMState>(state.loadAcquire());
+}

src/base/ai/abstractllm.h

@@ -14,6 +14,11 @@ class AbstractLLM : public QObject
 {
     Q_OBJECT
 public:
+    enum LLMState {
+        Idle = 0,
+        Busy
+    };
+
     enum ResponseState {
         Receiving,
         Success,
@@ -22,6 +27,13 @@ class AbstractLLM : public QObject
         Canceled
     };
 
+    enum Locale {
+        Zh,
+        En
+    };
+
+    using ResponseHandler = std::function<void(const QString &data, ResponseState state)>;
+
     explicit AbstractLLM(QObject *parent = nullptr);
     virtual ~AbstractLLM() {}
 
@@ -30,18 +42,25 @@ class AbstractLLM : public QObject
     virtual bool checkValid(QString *errStr) = 0;
     virtual QJsonObject create(const Conversation &conversation) = 0;
     virtual void request(const QJsonObject &data) = 0;
-    virtual void request(const QString &prompt) = 0;
-    virtual void generate(const QString &prompt, const QString &suffix) = 0;
+    virtual void request(const QString &prompt, ResponseHandler handler = nullptr) = 0;
+    virtual void generate(const QString &prefix, const QString &suffix) = 0; // use to auto compelte
     virtual void setTemperature(double temperature) = 0;
     virtual void setStream(bool isStream) = 0;
-    virtual void processResponse(QNetworkReply *reply) = 0;
+    virtual void setLocale(Locale lc) = 0;
     virtual void cancel() = 0;
     virtual void setMaxTokens(int maxToken) = 0;
     virtual Conversation *getCurrentConversation() = 0;
-    virtual bool isIdle() = 0;
+
+    void setModelState(LLMState st);
+    LLMState modelState() const;
 
 signals:
-    void dataReceived(const QString &data, ResponseState statu);
+    void customDataReceived(const QString &key, const QJsonObject &customData);
+    void dataReceived(const QString &data, ResponseState state);
+    void modelStateChanged();
+
+private:
+    QAtomicInt state { Idle };
 };
 
 #endif

src/base/ai/conversation.cpp

@@ -70,7 +70,21 @@
     return false;
 }
 
+bool Conversation::addResponse(const QString &data)
+{
+    if (!data.isEmpty()) {
+        const QJsonDocument &document = QJsonDocument::fromJson(data.toUtf8());
+        if (document.isArray()) {
+            conversation = document.array();
+        } else {
+            conversation.push_back(QJsonObject({ { "role", "assistant" }, {"content", data} }));
+        }
+        return true;
+    }
+    return false;
+}
+
 QString Conversation::getLastResponse() const
 {
     if (!conversation.isEmpty() && conversation.last()["role"].toString() == "assistant") {
         return conversation.last()["content"].toString();

src/base/ai/conversation.h

@@ -28,6 +28,7 @@ class Conversation
     bool addUserData(const QString &data);
     bool popUserData();
 
+    bool addResponse(const QString &data);
     QString getLastResponse() const;
     QByteArray getLastByteResponse() const;
     bool popLastResponse();

src/plugins/aimanager/aimanager.cpp

@@ -3,20 +3,28 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "aimanager.h"
 #include "services/ai/aiservice.h"
 #include "openai/openaicompatiblellm.h"
+#include "openai/openaicompletionprovider.h"
 #include "services/option/optionmanager.h"
+#include "services/editor/editorservice.h"
 #include "option/detailwidget.h"
 #include "common/util/eventdefinitions.h"
+#include "codegeex/codegeexllm.h"
+#include "codegeex/codegeexcompletionprovider.h"
 
 #include <QMap>
 
+static const char *kCodeGeeXModelPath = "https://codegeex.cn/prod/code/chatCodeSseV3/chat";
+
 using namespace dpfservice;
 
 class AiManagerPrivate
 {
 public:
     QList<LLMInfo> models;
+    CodeGeeXCompletionProvider *cgcProvider = nullptr;
+    OpenAiCompletionProvider *oacProvider = nullptr;
 };
 
 AiManager *AiManager::instance()
@@ -29,6 +37,7 @@
 : QObject(parent)
 , d(new AiManagerPrivate)
 {
+    initCompleteProvider();
     readLLMFromOption();
 }
 
@@ -52,6 +61,11 @@
             if (!info.apikey.isEmpty())
                 llm->setApiKey(info.apikey);
             return llm;
+        } else if (info.type == LLMType::ZHIPU_CODEGEEX) {
+            auto llm = new CodeGeeXLLM(this);
+            llm->setModelName(info.modelName);
+            llm->setModelPath(info.modelPath);
+            return llm;
         }
     }
 
@@ -100,6 +114,59 @@
         appendModel(info);
     }
 
+    for (LLMInfo defaultLLM : getDefaultLLM()) {
+        if (!d->models.contains(defaultLLM))
+            appendModel(defaultLLM);
+    }
+
     if (changed)
         ai.LLMChanged();
+
+    if (!map.value(kCATEGORY_AUTO_COMPLETE).isValid()) {
+        d->cgcProvider->setInlineCompletionEnabled(false);
+        d->oacProvider->setInlineCompletionEnabled(false);
+        return;
+    }
+
+    auto currentCompleteLLMInfo = LLMInfo::fromVariantMap(map.value(kCATEGORY_AUTO_COMPLETE).toMap());
+    if (currentCompleteLLMInfo.type == LLMType::OPENAI) {
+        d->oacProvider->setInlineCompletionEnabled(true);
+        d->oacProvider->setLLM(getLLM(currentCompleteLLMInfo));
+        d->cgcProvider->setInlineCompletionEnabled(false); // codegeex completion provider use default url
+    } else if (currentCompleteLLMInfo.type == LLMType::ZHIPU_CODEGEEX) {
+        d->cgcProvider->setInlineCompletionEnabled(true);
+        d->oacProvider->setInlineCompletionEnabled(false);
+    }
+}
+
+void AiManager::initCompleteProvider()
+{
+    d->cgcProvider = new CodeGeeXCompletionProvider(this);
+    d->oacProvider = new OpenAiCompletionProvider(this);
+    d->cgcProvider->setInlineCompletionEnabled(false);
+    d->oacProvider->setInlineCompletionEnabled(false);
+
+    connect(&dpf::Listener::instance(), &dpf::Listener::pluginsStarted, this, [=] {
+        auto editorService = dpfGetService(EditorService);
+        d->cgcProvider->setInlineCompletionEnabled(true);
+        editorService->registerInlineCompletionProvider(d->cgcProvider);
+        editorService->registerInlineCompletionProvider(d->oacProvider);
+    }, Qt::DirectConnection);
+}
+
+QList<LLMInfo> AiManager::getDefaultLLM()
+{
+    LLMInfo liteInfo;
+    liteInfo.icon = QIcon::fromTheme("codegeex_model_lite");
+    liteInfo.modelName = CodeGeeXChatModelLite;
+    liteInfo.modelPath = kCodeGeeXModelPath;
+    liteInfo.type = LLMType::ZHIPU_CODEGEEX;
+
+    LLMInfo proInfo;
+    proInfo.icon = QIcon::fromTheme("codegeex_model_pro");
+    proInfo.modelName = CodeGeeXChatModelPro;
+    proInfo.modelPath = kCodeGeeXModelPath;
+    proInfo.type = LLMType::ZHIPU_CODEGEEX;
+
+    return { liteInfo, proInfo };
 }

src/plugins/aimanager/aimanager.h

@@ -9,7 +9,10 @@
 
 // option manager -> custom models
 static const char *kCATEGORY_CUSTOMMODELS = "CustomModels";
+static const char *kCATEGORY_AUTO_COMPLETE = "AutoComplete";
 static const char *kCATEGORY_OPTIONKEY = "OptionKey";
+static const char *CodeGeeXChatModelLite = "codegeex-4";
+static const char *CodeGeeXChatModelPro = "codegeex-chat-pro";
 
 class AiManagerPrivate;
 class AiManager : public QObject
@@ -25,8 +28,10 @@ class AiManager : public QObject
     void appendModel(const LLMInfo &LLMInfo);
     void removeModel(const LLMInfo &LLMInfo);
     bool checkModelValid(const LLMInfo &info, QString *errStr);
+    QList<LLMInfo> getDefaultLLM();
 
     void readLLMFromOption();
+    void initCompleteProvider();
 
 private:
     AiManager(QObject *parent = nullptr);

src/plugins/aimanager/aimanager.qrc

@@ -1,4 +1,6 @@
 <RCC>
-    <qresource prefix="/aimanager">
+    <qresource prefix="/icons/deepin">
+        <file>builtin/icons/codegeex_model_lite_16px.svg</file>
+        <file>builtin/icons/codegeex_model_pro_16px.svg</file>
     </qresource>
 </RCC>

src/plugins/aimanager/aiplugin.cpp

@@ -26,11 +26,24 @@
     using namespace std::placeholders;
     aiService->getAllModel = std::bind(&AiManager::getAllModel, impl);
     aiService->getLLM = std::bind(&AiManager::getLLM, impl, _1);
+    aiService->getCodeGeeXLLMLite = []() -> LLMInfo {
+        auto defaultLLMs = AiManager::instance()->getDefaultLLM();
+        for (auto llm : defaultLLMs) {
+            if (llm.modelName == CodeGeeXChatModelLite)
+                return llm;
+        }
+    };
+    aiService->getCodeGeeXLLMPro = []() -> LLMInfo {
+        auto defaultLLMs = AiManager::instance()->getDefaultLLM();
+        for (auto llm : defaultLLMs) {
+            if (llm.modelName == CodeGeeXChatModelPro)
+                return llm;
+        }
+    };
 
     auto optionService = dpfGetService(dpfservice::OptionService);
     if (optionService) {
-// TODO:uncomment the code when everything is ok 
-//        optionService->implGenerator<OptionCustomModelsGenerator>(option::GROUP_AI, OptionCustomModelsGenerator::kitName());
+        optionService->implGenerator<OptionCustomModelsGenerator>(option::GROUP_AI, OptionCustomModelsGenerator::kitName());
     }
 
     return true;