mirror/QodeAssist
1
0
Fork 0
mirror of https://github.com/Palm1r/QodeAssist.git synced 2026-06-12 17:29:13 -04:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Add external LLMCore lib (#334)

Browse Source 
* feat: Add LLMCore submodule
This commit is contained in:
Petr Mironychev
2026-04-03 12:30:40 +02:00
committed by GitHub
parent 15d714588f
commit 6c05f0d594
137 changed files with 1340 additions and 4905 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/build_cmake.yml vendored
View File

@@ -56,6 +56,8 @@ jobs:
steps:
- uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955
with:
submodules: recursive
- name: Checkout submodules
id: git

3
.gitmodules vendored
View File

@@ -0,0 +1,3 @@
[submodule "sources/external/llmcore"]
path = sources/external/llmcore
url = https://github.com/Palm1r/llmcore.git

14
CMakeLists.txt
View File

@@ -34,7 +34,8 @@ add_definitions(
-DQODEASSIST_QT_CREATOR_VERSION_PATCH=${QODEASSIST_QT_CREATOR_VERSION_PATCH}
)
add_subdirectory(llmcore)
add_subdirectory(sources/external/llmcore)
add_subdirectory(pluginllmcore)
add_subdirectory(settings)
add_subdirectory(logger)
add_subdirectory(UIControls)
@@ -61,6 +62,8 @@ add_qtc_plugin(QodeAssist
QtCreator::ExtensionSystem
QtCreator::Utils
QtCreator::CPlusPlus
LLMCore
PluginLLMCore
QodeAssistChatViewplugin
SOURCES
.github/workflows/build_cmake.yml
@@ -112,7 +115,6 @@ add_qtc_plugin(QodeAssist
providers/OpenAIResponses/ItemTypesReference.hpp
providers/OpenAIResponsesRequestBuilder.hpp
providers/OpenAIResponsesProvider.hpp providers/OpenAIResponsesProvider.cpp
providers/OpenAIResponsesMessage.hpp providers/OpenAIResponsesMessage.cpp
QodeAssist.qrc
LSPCompletion.hpp
LLMSuggestion.hpp LLMSuggestion.cpp
@@ -141,10 +143,8 @@ add_qtc_plugin(QodeAssist
widgets/DiffStatistics.hpp
QuickRefactorHandler.hpp QuickRefactorHandler.cpp
tools/ToolsFactory.hpp tools/ToolsFactory.cpp
tools/ToolHandler.hpp tools/ToolHandler.cpp
tools/ToolsRegistration.hpp tools/ToolsRegistration.cpp
tools/ListProjectFilesTool.hpp tools/ListProjectFilesTool.cpp
tools/ToolsManager.hpp tools/ToolsManager.cpp
tools/GetIssuesListTool.hpp tools/GetIssuesListTool.cpp
tools/CreateNewFileTool.hpp tools/CreateNewFileTool.cpp
tools/EditFileTool.hpp tools/EditFileTool.cpp
@@ -154,10 +154,6 @@ add_qtc_plugin(QodeAssist
tools/FindAndReadFileTool.hpp tools/FindAndReadFileTool.cpp
tools/FileSearchUtils.hpp tools/FileSearchUtils.cpp
tools/TodoTool.hpp tools/TodoTool.cpp
providers/ClaudeMessage.hpp providers/ClaudeMessage.cpp
providers/OpenAIMessage.hpp providers/OpenAIMessage.cpp
providers/OllamaMessage.hpp providers/OllamaMessage.cpp
providers/GoogleMessage.hpp providers/GoogleMessage.cpp
)
get_target_property(QtCreatorCorePath QtCreator::Core LOCATION)

3
ChatView/CMakeLists.txt
View File

@@ -80,11 +80,12 @@ target_link_libraries(QodeAssistChatView
Qt::Network
QtCreator::Core
QtCreator::Utils
LLMCore
PluginLLMCore
QodeAssistSettings
Context
QodeAssistUIControlsplugin
QodeAssistLogger
LLMCore
)
target_include_directories(QodeAssistChatView

37
ChatView/ChatCompressor.cpp
View File

@@ -18,6 +18,8 @@
*/
#include "ChatCompressor.hpp"
#include <LLMCore/BaseClient.hpp>
#include "ChatModel.hpp"
#include "GeneralSettings.hpp"
#include "PromptTemplateManager.hpp"
@@ -56,7 +58,7 @@ void ChatCompressor::startCompression(const QString &chatFilePath, ChatModel *ch
}
auto providerName = Settings::generalSettings().caProvider();
m_provider = LLMCore::ProvidersManager::instance().getProviderByName(providerName);
m_provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
if (!m_provider) {
emit compressionFailed(tr("No provider available"));
@@ -64,7 +66,7 @@ void ChatCompressor::startCompression(const QString &chatFilePath, ChatModel *ch
}
auto templateName = Settings::generalSettings().caTemplate();
auto promptTemplate = LLMCore::PromptTemplateManager::instance().getChatTemplateByName(
auto promptTemplate = PluginLLMCore::PromptTemplateManager::instance().getChatTemplateByName(
templateName);
if (!promptTemplate) {
@@ -76,7 +78,6 @@ void ChatCompressor::startCompression(const QString &chatFilePath, ChatModel *ch
m_chatModel = chatModel;
m_originalChatPath = chatFilePath;
m_accumulatedSummary.clear();
m_currentRequestId = QUuid::createUuid().toString(QUuid::WithoutBraces);
emit compressionStarted();
@@ -85,7 +86,7 @@ void ChatCompressor::startCompression(const QString &chatFilePath, ChatModel *ch
QUrl requestUrl;
QJsonObject payload;
if (m_provider->providerID() == LLMCore::ProviderID::GoogleAI) {
if (m_provider->providerID() == PluginLLMCore::ProviderID::GoogleAI) {
requestUrl = QUrl(QString("%1/models/%2:streamGenerateContent?alt=sse")
.arg(Settings::generalSettings().caUrl(),
Settings::generalSettings().caModel()));
@@ -98,8 +99,8 @@ void ChatCompressor::startCompression(const QString &chatFilePath, ChatModel *ch
buildRequestPayload(payload, promptTemplate);
m_currentRequestId = m_provider->sendRequest(requestUrl, payload);
LOG_MESSAGE(QString("Starting compression request: %1").arg(m_currentRequestId));
m_provider->sendRequest(m_currentRequestId, requestUrl, payload);
}
bool ChatCompressor::isCompressing() const
@@ -188,28 +189,28 @@ QString ChatCompressor::buildCompressionPrompt() const
}
void ChatCompressor::buildRequestPayload(
QJsonObject &payload, LLMCore::PromptTemplate *promptTemplate)
QJsonObject &payload, PluginLLMCore::PromptTemplate *promptTemplate)
{
LLMCore::ContextData context;
PluginLLMCore::ContextData context;
context.systemPrompt = QStringLiteral(
"You are a helpful assistant that creates concise summaries of conversations. "
"Your summaries preserve key information, technical details, and the flow of discussion.");
QVector<LLMCore::Message> messages;
QVector<PluginLLMCore::Message> messages;
for (const auto &msg : m_chatModel->getChatHistory()) {
if (msg.role == ChatModel::ChatRole::Tool
|| msg.role == ChatModel::ChatRole::FileEdit
|| msg.role == ChatModel::ChatRole::Thinking)
continue;
LLMCore::Message apiMessage;
PluginLLMCore::Message apiMessage;
apiMessage.role = (msg.role == ChatModel::ChatRole::User) ? "user" : "assistant";
apiMessage.content = msg.content;
messages.append(apiMessage);
}
LLMCore::Message compressionRequest;
PluginLLMCore::Message compressionRequest;
compressionRequest.role = "user";
compressionRequest.content = buildCompressionPrompt();
messages.append(compressionRequest);
@@ -217,7 +218,7 @@ void ChatCompressor::buildRequestPayload(
context.history = messages;
m_provider->prepareRequest(
payload, promptTemplate, context, LLMCore::RequestType::Chat, false, false);
payload, promptTemplate, context, PluginLLMCore::RequestType::Chat, false, false);
}
bool ChatCompressor::createCompressedChatFile(
@@ -266,23 +267,25 @@ bool ChatCompressor::createCompressedChatFile(
void ChatCompressor::connectProviderSignals()
{
auto *c = m_provider->client();
m_connections.append(connect(
m_provider,
&LLMCore::Provider::partialResponseReceived,
c,
&::LLMCore::BaseClient::chunkReceived,
this,
&ChatCompressor::onPartialResponseReceived,
Qt::UniqueConnection));
m_connections.append(connect(
m_provider,
&LLMCore::Provider::fullResponseReceived,
c,
&::LLMCore::BaseClient::requestCompleted,
this,
&ChatCompressor::onFullResponseReceived,
Qt::UniqueConnection));
m_connections.append(connect(
m_provider,
&LLMCore::Provider::requestFailed,
c,
&::LLMCore::BaseClient::requestFailed,
this,
&ChatCompressor::onRequestFailed,
Qt::UniqueConnection));

8
ChatView/ChatCompressor.hpp
View File

@@ -24,10 +24,10 @@
#include <QObject>
#include <QString>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class Provider;
class PromptTemplate;
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore
namespace QodeAssist::Chat {
@@ -64,13 +64,13 @@ private:
void disconnectAllSignals();
void cleanupState();
void handleCompressionError(const QString &error);
void buildRequestPayload(QJsonObject &payload, LLMCore::PromptTemplate *promptTemplate);
void buildRequestPayload(QJsonObject &payload, PluginLLMCore::PromptTemplate *promptTemplate);
bool m_isCompressing = false;
QString m_currentRequestId;
QString m_originalChatPath;
QString m_accumulatedSummary;
LLMCore::Provider *m_provider = nullptr;
PluginLLMCore::Provider *m_provider = nullptr;
ChatModel *m_chatModel = nullptr;
QList<QMetaObject::Connection> m_connections;

14
ChatView/ChatRootView.cpp
View File

@@ -51,14 +51,14 @@
#include "context/ChangesManager.h"
#include "context/ContextManager.hpp"
#include "context/TokenUtils.hpp"
#include "llmcore/RulesLoader.hpp"
#include "pluginllmcore/RulesLoader.hpp"
namespace QodeAssist::Chat {
ChatRootView::ChatRootView(QQuickItem *parent)
: QQuickItem(parent)
, m_chatModel(new ChatModel(this))
, m_promptProvider(LLMCore::PromptTemplateManager::instance())
, m_promptProvider(PluginLLMCore::PromptTemplateManager::instance())
, m_clientInterface(new ClientInterface(m_chatModel, &m_promptProvider, this))
, m_fileManager(new ChatFileManager(this))
, m_isRequestInProgress(false)
@@ -929,7 +929,7 @@ QString ChatRootView::getRuleContent(int index)
if (index < 0 || index >= m_activeRules.size())
return QString();
return LLMCore::RulesLoader::loadRuleFileContent(
return PluginLLMCore::RulesLoader::loadRuleFileContent(
m_activeRules[index].toMap()["filePath"].toString());
}
@@ -937,7 +937,7 @@ void ChatRootView::refreshRules()
{
m_activeRules.clear();
auto project = LLMCore::RulesLoader::getActiveProject();
auto project = PluginLLMCore::RulesLoader::getActiveProject();
if (!project) {
emit activeRulesChanged();
emit activeRulesCountChanged();
@@ -945,7 +945,7 @@ void ChatRootView::refreshRules()
}
auto ruleFiles
= LLMCore::RulesLoader::getRuleFilesForProject(project, LLMCore::RulesContext::Chat);
= PluginLLMCore::RulesLoader::getRuleFilesForProject(project, PluginLLMCore::RulesContext::Chat);
for (const auto &ruleFile : ruleFiles) {
QVariantMap ruleMap;
@@ -1296,9 +1296,9 @@ QString ChatRootView::lastInfoMessage() const
bool ChatRootView::isThinkingSupport() const
{
auto providerName = Settings::generalSettings().caProvider();
auto provider = LLMCore::ProvidersManager::instance().getProviderByName(providerName);
auto provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
return provider && provider->supportThinking();
return provider && provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::Thinking);
}
QString ChatRootView::generateChatFileName(const QString &shortMessage, const QString &dir) const

4
ChatView/ChatRootView.hpp
View File

@@ -25,7 +25,7 @@
#include "ChatFileManager.hpp"
#include "ChatModel.hpp"
#include "ClientInterface.hpp"
#include "llmcore/PromptProviderChat.hpp"
#include "pluginllmcore/PromptProviderChat.hpp"
#include <coreplugin/editormanager/editormanager.h>
namespace QodeAssist::Chat {
@@ -235,7 +235,7 @@ private:
bool hasImageAttachments(const QStringList &attachments) const;
ChatModel *m_chatModel;
LLMCore::PromptProviderChat m_promptProvider;
PluginLLMCore::PromptProviderChat m_promptProvider;
ClientInterface *m_clientInterface;
ChatFileManager *m_fileManager;
QString m_currentTemplate;

209
ChatView/ClientInterface.cpp
View File

@@ -19,6 +19,8 @@
#include "ClientInterface.hpp"
#include <LLMCore/BaseClient.hpp>
#include <projectexplorer/buildconfiguration.h>
#include <projectexplorer/target.h>
#include <texteditor/textdocument.h>
@@ -40,6 +42,10 @@
#include <texteditor/textdocument.h>
#include <texteditor/texteditor.h>
#include <LLMCore/ToolsManager.hpp>
#include "tools/TodoTool.hpp"
#include "ChatAssistantSettings.hpp"
#include "ChatSerializer.hpp"
#include "GeneralSettings.hpp"
@@ -53,7 +59,7 @@
namespace QodeAssist::Chat {
ClientInterface::ClientInterface(
ChatModel *chatModel, LLMCore::IPromptProvider *promptProvider, QObject *parent)
ChatModel *chatModel, PluginLLMCore::IPromptProvider *promptProvider, QObject *parent)
: QObject(parent)
, m_chatModel(chatModel)
, m_promptProvider(promptProvider)
@@ -138,7 +144,7 @@ void ClientInterface::sendMessage(
auto &chatAssistantSettings = Settings::chatAssistantSettings();
auto providerName = Settings::generalSettings().caProvider();
auto provider = LLMCore::ProvidersManager::instance().getProviderByName(providerName);
auto provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
if (!provider) {
LOG_MESSAGE(QString("No provider found with name: %1").arg(providerName));
@@ -153,7 +159,7 @@ void ClientInterface::sendMessage(
return;
}
LLMCore::ContextData context;
PluginLLMCore::ContextData context;
const bool isToolsEnabled = useTools;
@@ -167,7 +173,7 @@ void ClientInterface::sendMessage(
systemPrompt = systemPrompt + "\n\n" + role.systemPrompt;
}
auto project = LLMCore::RulesLoader::getActiveProject();
auto project = PluginLLMCore::RulesLoader::getActiveProject();
if (project) {
systemPrompt += QString("\n# Active project name: %1").arg(project->displayName());
@@ -182,7 +188,7 @@ void ClientInterface::sendMessage(
}
QString projectRules
= LLMCore::RulesLoader::loadRulesForProject(project, LLMCore::RulesContext::Chat);
= PluginLLMCore::RulesLoader::loadRulesForProject(project, PluginLLMCore::RulesContext::Chat);
if (!projectRules.isEmpty()) {
systemPrompt += QString("\n# Project Rules\n\n") + projectRules;
@@ -197,13 +203,13 @@ void ClientInterface::sendMessage(
context.systemPrompt = systemPrompt;
}
QVector<LLMCore::Message> messages;
QVector<PluginLLMCore::Message> messages;
for (const auto &msg : m_chatModel->getChatHistory()) {
if (msg.role == ChatModel::ChatRole::Tool || msg.role == ChatModel::ChatRole::FileEdit) {
continue;
}
LLMCore::Message apiMessage;
PluginLLMCore::Message apiMessage;
apiMessage.role = msg.role == ChatModel::ChatRole::User ? "user" : "assistant";
apiMessage.content = msg.content;
@@ -223,7 +229,8 @@ void ClientInterface::sendMessage(
apiMessage.isRedacted = msg.isRedacted;
apiMessage.signature = msg.signature;
if (provider->supportImage() && !m_chatFilePath.isEmpty() && !msg.images.isEmpty()) {
if (provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::Image)
&& !m_chatFilePath.isEmpty() && !msg.images.isEmpty()) {
auto apiImages = loadImagesFromStorage(msg.images);
if (!apiImages.isEmpty()) {
apiMessage.images = apiImages;
@@ -233,18 +240,19 @@ void ClientInterface::sendMessage(
messages.append(apiMessage);
}
if (!imageFiles.isEmpty() && !provider->supportImage()) {
if (!imageFiles.isEmpty()
&& !provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::Image)) {
LOG_MESSAGE(QString("Provider %1 doesn't support images, %2 ignored")
.arg(provider->name(), QString::number(imageFiles.size())));
}
context.history = messages;
LLMCore::LLMConfig config;
config.requestType = LLMCore::RequestType::Chat;
PluginLLMCore::LLMConfig config;
config.requestType = PluginLLMCore::RequestType::Chat;
config.provider = provider;
config.promptTemplate = promptTemplate;
if (provider->providerID() == LLMCore::ProviderID::GoogleAI) {
if (provider->providerID() == PluginLLMCore::ProviderID::GoogleAI) {
QString stream = QString{"streamGenerateContent?alt=sse"};
config.url = QUrl(QString("%1/models/%2:%3")
.arg(
@@ -258,87 +266,79 @@ void ClientInterface::sendMessage(
= {{"model", Settings::generalSettings().caModel()}, {"stream", true}};
}
config.apiKey = provider->apiKey();
config.provider->prepareRequest(
config.providerRequest,
promptTemplate,
context,
LLMCore::RequestType::Chat,
PluginLLMCore::RequestType::Chat,
useTools,
useThinking);
QString requestId = QUuid::createUuid().toString();
connect(
provider->client(),
&::LLMCore::BaseClient::chunkReceived,
this,
&ClientInterface::handlePartialResponse,
Qt::UniqueConnection);
connect(
provider->client(),
&::LLMCore::BaseClient::requestCompleted,
this,
&ClientInterface::handleFullResponse,
Qt::UniqueConnection);
connect(
provider->client(),
&::LLMCore::BaseClient::requestFailed,
this,
&ClientInterface::handleRequestFailed,
Qt::UniqueConnection);
connect(
provider->client(),
&::LLMCore::BaseClient::toolStarted,
this,
&ClientInterface::handleToolExecutionStarted,
Qt::UniqueConnection);
connect(
provider->client(),
&::LLMCore::BaseClient::toolResultReady,
this,
&ClientInterface::handleToolExecutionCompleted,
Qt::UniqueConnection);
connect(
provider->client(),
&::LLMCore::BaseClient::thinkingBlockReceived,
this,
&ClientInterface::handleThinkingBlockReceived,
Qt::UniqueConnection);
auto requestId = provider->sendRequest(config.url, config.providerRequest);
QJsonObject request{{"id", requestId}};
m_activeRequests[requestId] = {request, provider};
emit requestStarted(requestId);
connect(
provider,
&LLMCore::Provider::partialResponseReceived,
this,
&ClientInterface::handlePartialResponse,
Qt::UniqueConnection);
connect(
provider,
&LLMCore::Provider::fullResponseReceived,
this,
&ClientInterface::handleFullResponse,
Qt::UniqueConnection);
connect(
provider,
&LLMCore::Provider::requestFailed,
this,
&ClientInterface::handleRequestFailed,
Qt::UniqueConnection);
connect(
provider,
&LLMCore::Provider::toolExecutionStarted,
this,
&ClientInterface::handleToolExecutionStarted,
Qt::UniqueConnection);
connect(
provider,
&LLMCore::Provider::toolExecutionCompleted,
this,
&ClientInterface::handleToolExecutionCompleted,
Qt::UniqueConnection);
connect(
provider,
&LLMCore::Provider::continuationStarted,
this,
&ClientInterface::handleCleanAccumulatedData,
Qt::UniqueConnection);
connect(
provider,
&LLMCore::Provider::thinkingBlockReceived,
this,
&ClientInterface::handleThinkingBlockReceived,
Qt::UniqueConnection);
connect(
provider,
&LLMCore::Provider::redactedThinkingBlockReceived,
this,
&ClientInterface::handleRedactedThinkingBlockReceived,
Qt::UniqueConnection);
provider->sendRequest(requestId, config.url, config.providerRequest);
if (provider->supportsTools() && provider->toolsManager()) {
provider->toolsManager()->setCurrentSessionId(m_chatFilePath);
if (provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::Tools)
&& provider->toolsManager()) {
if (auto *todoTool = qobject_cast<QodeAssist::Tools::TodoTool *>(
provider->toolsManager()->tool("todo_tool"))) {
todoTool->setCurrentSessionId(m_chatFilePath);
}
}
}
void ClientInterface::clearMessages()
{
const auto providerName = Settings::generalSettings().caProvider();
auto *provider = LLMCore::ProvidersManager::instance().getProviderByName(providerName);
auto *provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
if (provider && !m_chatFilePath.isEmpty() && provider->supportsTools()
if (provider && !m_chatFilePath.isEmpty()
&& provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::Tools)
&& provider->toolsManager()) {
provider->toolsManager()->clearTodoSession(m_chatFilePath);
if (auto *todoTool = qobject_cast<QodeAssist::Tools::TodoTool *>(
provider->toolsManager()->tool("todo_tool"))) {
todoTool->clearSession(m_chatFilePath);
}
}
m_chatModel->clear();
@@ -346,7 +346,7 @@ void ClientInterface::clearMessages()
void ClientInterface::cancelRequest()
{
QSet<LLMCore::Provider *> providers;
QSet<PluginLLMCore::Provider *> providers;
for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
if (it.value().provider) {
providers.insert(it.value().provider);
@@ -354,7 +354,7 @@ void ClientInterface::cancelRequest()
}
for (auto *provider : providers) {
disconnect(provider, nullptr, this, nullptr);
disconnect(provider->client(), nullptr, this, nullptr);
}
for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
@@ -366,6 +366,7 @@ void ClientInterface::cancelRequest()
m_activeRequests.clear();
m_accumulatedResponses.clear();
m_awaitingContinuation.clear();
LOG_MESSAGE("All requests cancelled and state cleared");
}
@@ -432,6 +433,12 @@ void ClientInterface::handlePartialResponse(const QString &requestId, const QStr
if (it == m_activeRequests.end())
return;
if (m_awaitingContinuation.remove(requestId)) {
m_accumulatedResponses[requestId].clear();
LOG_MESSAGE(
QString("Cleared accumulated responses for continuation request %1").arg(requestId));
}
m_accumulatedResponses[requestId] += partialText;
const RequestContext &ctx = it.value();
@@ -462,12 +469,9 @@ void ClientInterface::handleFullResponse(const QString &requestId, const QString
+ ": " + finalText);
emit messageReceivedCompletely();
if (it != m_activeRequests.end()) {
m_activeRequests.erase(it);
}
if (m_accumulatedResponses.contains(requestId)) {
m_accumulatedResponses.remove(requestId);
}
m_awaitingContinuation.remove(requestId);
}
void ClientInterface::handleRequestFailed(const QString &requestId, const QString &error)
@@ -479,18 +483,9 @@ void ClientInterface::handleRequestFailed(const QString &requestId, const QStrin
LOG_MESSAGE(QString("Chat request %1 failed: %2").arg(requestId, error));
emit errorOccurred(error);
if (it != m_activeRequests.end()) {
m_activeRequests.erase(it);
}
if (m_accumulatedResponses.contains(requestId)) {
m_accumulatedResponses.remove(requestId);
}
}
void ClientInterface::handleCleanAccumulatedData(const QString &requestId)
{
m_accumulatedResponses[requestId].clear();
LOG_MESSAGE(QString("Cleared accumulated responses for continuation request %1").arg(requestId));
m_awaitingContinuation.remove(requestId);
}
void ClientInterface::handleThinkingBlockReceived(
@@ -501,19 +496,17 @@ void ClientInterface::handleThinkingBlockReceived(
return;
}
if (m_awaitingContinuation.remove(requestId)) {
m_accumulatedResponses[requestId].clear();
LOG_MESSAGE(
QString("Cleared accumulated responses for continuation request %1").arg(requestId));
}
if (thinking.isEmpty()) {
m_chatModel->addRedactedThinkingBlock(requestId, signature);
} else {
m_chatModel->addThinkingBlock(requestId, thinking, signature);
}
void ClientInterface::handleRedactedThinkingBlockReceived(
const QString &requestId, const QString &signature)
{
if (!m_activeRequests.contains(requestId)) {
LOG_MESSAGE(
QString("Ignoring redacted thinking block for non-chat request: %1").arg(requestId));
return;
}
m_chatModel->addRedactedThinkingBlock(requestId, signature);
}
void ClientInterface::handleToolExecutionStarted(
@@ -525,6 +518,7 @@ void ClientInterface::handleToolExecutionStarted(
}
m_chatModel->addToolExecutionStatus(requestId, toolId, toolName);
m_awaitingContinuation.insert(requestId);
}
void ClientInterface::handleToolExecutionCompleted(
@@ -588,10 +582,10 @@ QString ClientInterface::encodeImageToBase64(const QString &filePath) const
return imageData.toBase64();
}
QVector<LLMCore::ImageAttachment> ClientInterface::loadImagesFromStorage(
QVector<PluginLLMCore::ImageAttachment> ClientInterface::loadImagesFromStorage(
const QList<ChatModel::ImageAttachment> &storedImages) const
{
QVector<LLMCore::ImageAttachment> apiImages;
QVector<PluginLLMCore::ImageAttachment> apiImages;
for (const auto &storedImage : storedImages) {
QString base64Data
@@ -601,7 +595,7 @@ QVector<LLMCore::ImageAttachment> ClientInterface::loadImagesFromStorage(
continue;
}
LLMCore::ImageAttachment apiImage;
PluginLLMCore::ImageAttachment apiImage;
apiImage.data = base64Data;
apiImage.mediaType = storedImage.mediaType;
apiImage.isUrl = false;
@@ -616,10 +610,15 @@ void ClientInterface::setChatFilePath(const QString &filePath)
{
if (!m_chatFilePath.isEmpty() && m_chatFilePath != filePath) {
const auto providerName = Settings::generalSettings().caProvider();
auto *provider = LLMCore::ProvidersManager::instance().getProviderByName(providerName);
auto *provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
if (provider && provider->supportsTools() && provider->toolsManager()) {
provider->toolsManager()->clearTodoSession(m_chatFilePath);
if (provider
&& provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::Tools)
&& provider->toolsManager()) {
if (auto *todoTool = qobject_cast<QodeAssist::Tools::TodoTool *>(
provider->toolsManager()->tool("todo_tool"))) {
todoTool->clearSession(m_chatFilePath);
}
}
}

14
ChatView/ClientInterface.hpp
View File

@@ -20,12 +20,13 @@
#pragma once
#include <QObject>
#include <QSet>
#include <QString>
#include <QVector>
#include "ChatModel.hpp"
#include "Provider.hpp"
#include "llmcore/IPromptProvider.hpp"
#include "pluginllmcore/IPromptProvider.hpp"
#include <context/ContextManager.hpp>
namespace QodeAssist::Chat {
@@ -36,7 +37,7 @@ class ClientInterface : public QObject
public:
explicit ClientInterface(
ChatModel *chatModel, LLMCore::IPromptProvider *promptProvider, QObject *parent = nullptr);
ChatModel *chatModel, PluginLLMCore::IPromptProvider *promptProvider, QObject *parent = nullptr);
~ClientInterface();
void sendMessage(
@@ -62,10 +63,8 @@ private slots:
void handlePartialResponse(const QString &requestId, const QString &partialText);
void handleFullResponse(const QString &requestId, const QString &fullText);
void handleRequestFailed(const QString &requestId, const QString &error);
void handleCleanAccumulatedData(const QString &requestId);
void handleThinkingBlockReceived(
const QString &requestId, const QString &thinking, const QString &signature);
void handleRedactedThinkingBlockReceived(const QString &requestId, const QString &signature);
void handleToolExecutionStarted(
const QString &requestId, const QString &toolId, const QString &toolName);
void handleToolExecutionCompleted(
@@ -82,21 +81,22 @@ private:
bool isImageFile(const QString &filePath) const;
QString getMediaTypeForImage(const QString &filePath) const;
QString encodeImageToBase64(const QString &filePath) const;
QVector<LLMCore::ImageAttachment> loadImagesFromStorage(const QList<ChatModel::ImageAttachment> &storedImages) const;
QVector<PluginLLMCore::ImageAttachment> loadImagesFromStorage(const QList<ChatModel::ImageAttachment> &storedImages) const;
struct RequestContext
{
QJsonObject originalRequest;
LLMCore::Provider *provider;
PluginLLMCore::Provider *provider;
};
LLMCore::IPromptProvider *m_promptProvider = nullptr;
PluginLLMCore::IPromptProvider *m_promptProvider = nullptr;
ChatModel *m_chatModel;
Context::ContextManager *m_contextManager;
QString m_chatFilePath;
QHash<QString, RequestContext> m_activeRequests;
QHash<QString, QString> m_accumulatedResponses;
QSet<QString> m_awaitingContinuation;
};
} // namespace QodeAssist::Chat

10
ConfigurationManager.cpp
View File

@@ -41,7 +41,7 @@ void ConfigurationManager::init()
void ConfigurationManager::updateTemplateDescription(const Utils::StringAspect &templateAspect)
{
LLMCore::PromptTemplate *templ = m_templateManger.getFimTemplateByName(templateAspect.value());
PluginLLMCore::PromptTemplate *templ = m_templateManger.getFimTemplateByName(templateAspect.value());
if (!templ) {
return;
@@ -65,7 +65,7 @@ void ConfigurationManager::updateAllTemplateDescriptions()
void ConfigurationManager::checkTemplate(const Utils::StringAspect &templateAspect)
{
LLMCore::PromptTemplate *templ = m_templateManger.getFimTemplateByName(templateAspect.value());
PluginLLMCore::PromptTemplate *templ = m_templateManger.getFimTemplateByName(templateAspect.value());
if (templ->name() == templateAspect.value())
return;
@@ -86,8 +86,8 @@ void ConfigurationManager::checkAllTemplate()
ConfigurationManager::ConfigurationManager(QObject *parent)
: QObject(parent)
, m_generalSettings(Settings::generalSettings())
, m_providersManager(LLMCore::ProvidersManager::instance())
, m_templateManger(LLMCore::PromptTemplateManager::instance())
, m_providersManager(PluginLLMCore::ProvidersManager::instance())
, m_templateManger(PluginLLMCore::PromptTemplateManager::instance())
{}
void ConfigurationManager::setupConnections()
@@ -176,7 +176,7 @@ void ConfigurationManager::selectModel()
: m_generalSettings.caModel);
if (auto provider = m_providersManager.getProviderByName(providerName)) {
if (!provider->supportsModelListing()) {
if (!provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::ModelListing)) {
m_generalSettings.showModelsNotSupportedDialog(*targetSettings);
return;
}

8
ConfigurationManager.hpp
View File

@@ -21,8 +21,8 @@
#include <QObject>
#include "llmcore/PromptTemplateManager.hpp"
#include "llmcore/ProvidersManager.hpp"
#include "pluginllmcore/PromptTemplateManager.hpp"
#include "pluginllmcore/ProvidersManager.hpp"
#include "settings/GeneralSettings.hpp"
namespace QodeAssist {
@@ -54,8 +54,8 @@ private:
ConfigurationManager &operator=(const ConfigurationManager &) = delete;
Settings::GeneralSettings &m_generalSettings;
LLMCore::ProvidersManager &m_providersManager;
LLMCore::PromptTemplateManager &m_templateManger;
PluginLLMCore::ProvidersManager &m_providersManager;
PluginLLMCore::PromptTemplateManager &m_templateManger;
void setupConnections();
};

70
LLMClientInterface.cpp
View File

@@ -19,6 +19,7 @@
#include "LLMClientInterface.hpp"
#include <LLMCore/BaseClient.hpp>
#include <QJsonDocument>
#include <QNetworkAccessManager>
#include <QNetworkReply>
@@ -29,16 +30,16 @@
#include "logger/Logger.hpp"
#include "settings/CodeCompletionSettings.hpp"
#include "settings/GeneralSettings.hpp"
#include <llmcore/RequestConfig.hpp>
#include <llmcore/RulesLoader.hpp>
#include <pluginllmcore/RequestConfig.hpp>
#include <pluginllmcore/RulesLoader.hpp>
namespace QodeAssist {
LLMClientInterface::LLMClientInterface(
const Settings::GeneralSettings &generalSettings,
const Settings::CodeCompletionSettings &completeSettings,
LLMCore::IProviderRegistry &providerRegistry,
LLMCore::IPromptProvider *promptProvider,
PluginLLMCore::IProviderRegistry &providerRegistry,
PluginLLMCore::IPromptProvider *promptProvider,
Context::IDocumentReader &documentReader,
IRequestPerformanceLogger &performanceLogger)
: m_generalSettings(generalSettings)
@@ -122,8 +123,6 @@ void LLMClientInterface::sendData(const QByteArray &data)
} else if (method == "textDocument/didOpen") {
handleTextDocumentDidOpen(request);
} else if (method == "getCompletionsCycling") {
QString requestId = request["id"].toString();
m_performanceLogger.startTimeMeasurement(requestId);
handleCompletion(request);
} else if (method == "$/cancelRequest") {
handleCancelRequest();
@@ -136,7 +135,7 @@ void LLMClientInterface::sendData(const QByteArray &data)
void LLMClientInterface::handleCancelRequest()
{
QSet<LLMCore::Provider *> providers;
QSet<PluginLLMCore::Provider *> providers;
for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
if (it.value().provider) {
providers.insert(it.value().provider);
@@ -144,7 +143,7 @@ void LLMClientInterface::handleCancelRequest()
}
for (auto *provider : providers) {
disconnect(provider, nullptr, this, nullptr);
disconnect(provider->client(), nullptr, this, nullptr);
}
for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
@@ -271,12 +270,12 @@ void LLMClientInterface::handleCompletion(const QJsonObject &request)
}
// TODO refactor to dynamic presets system
LLMCore::LLMConfig config;
config.requestType = LLMCore::RequestType::CodeCompletion;
PluginLLMCore::LLMConfig config;
config.requestType = PluginLLMCore::RequestType::CodeCompletion;
config.provider = provider;
config.promptTemplate = promptTemplate;
// TODO refactor networking
if (provider->providerID() == LLMCore::ProviderID::GoogleAI) {
if (provider->providerID() == PluginLLMCore::ProviderID::GoogleAI) {
QString stream = QString{"streamGenerateContent?alt=sse"};
config.url = QUrl(QString("%1/models/%2:%3").arg(url, modelName, stream));
} else {
@@ -284,7 +283,6 @@ void LLMClientInterface::handleCompletion(const QJsonObject &request)
QString("%1%2").arg(url, endpoint(provider, promptTemplate->type(), isPreset1Active)));
config.providerRequest = {{"model", modelName}, {"stream", true}};
}
config.apiKey = provider->apiKey();
config.multiLineCompletion = m_completeSettings.multiLineCompletion();
const auto stopWords = QJsonArray::fromStringList(config.promptTemplate->stopWords());
@@ -295,14 +293,14 @@ void LLMClientInterface::handleCompletion(const QJsonObject &request)
if (m_completeSettings.useSystemPrompt())
systemPrompt.append(
m_completeSettings.useUserMessageTemplateForCC()
&& promptTemplate->type() == LLMCore::TemplateType::Chat
&& promptTemplate->type() == PluginLLMCore::TemplateType::Chat
? m_completeSettings.systemPromptForNonFimModels()
: m_completeSettings.systemPrompt());
auto project = LLMCore::RulesLoader::getActiveProject();
auto project = PluginLLMCore::RulesLoader::getActiveProject();
if (project) {
QString projectRules
= LLMCore::RulesLoader::loadRulesForProject(project, LLMCore::RulesContext::Completions);
= PluginLLMCore::RulesLoader::loadRulesForProject(project, PluginLLMCore::RulesContext::Completions);
if (!projectRules.isEmpty()) {
systemPrompt += "\n\n# Project Rules\n\n" + projectRules;
@@ -314,10 +312,10 @@ void LLMClientInterface::handleCompletion(const QJsonObject &request)
systemPrompt.append(updatedContext.fileContext.value());
if (m_completeSettings.useOpenFilesContext()) {
if (provider->providerID() == LLMCore::ProviderID::LlamaCpp) {
if (provider->providerID() == PluginLLMCore::ProviderID::LlamaCpp) {
for (const auto openedFilePath : m_contextManager->openedFiles({filePath})) {
if (!updatedContext.filesMetadata) {
updatedContext.filesMetadata = QList<LLMCore::FileMetadata>();
updatedContext.filesMetadata = QList<PluginLLMCore::FileMetadata>();
}
updatedContext.filesMetadata->append({openedFilePath.first, openedFilePath.second});
}
@@ -328,7 +326,7 @@ void LLMClientInterface::handleCompletion(const QJsonObject &request)
updatedContext.systemPrompt = systemPrompt;
if (promptTemplate->type() == LLMCore::TemplateType::Chat) {
if (promptTemplate->type() == PluginLLMCore::TemplateType::Chat) {
QString userMessage;
if (m_completeSettings.useUserMessageTemplateForCC()) {
userMessage = m_completeSettings.processMessageToFIM(
@@ -338,7 +336,7 @@ void LLMClientInterface::handleCompletion(const QJsonObject &request)
}
// TODO refactor add message
QVector<LLMCore::Message> messages;
QVector<PluginLLMCore::Message> messages;
messages.append({"user", userMessage});
updatedContext.history = messages;
}
@@ -347,41 +345,29 @@ void LLMClientInterface::handleCompletion(const QJsonObject &request)
config.providerRequest,
promptTemplate,
updatedContext,
LLMCore::RequestType::CodeCompletion,
PluginLLMCore::RequestType::CodeCompletion,
false,
false);
auto errors = config.provider->validateRequest(config.providerRequest, promptTemplate->type());
if (!errors.isEmpty()) {
QString error = QString("Request validation failed: %1").arg(errors.join("; "));
LOG_MESSAGE("Validate errors for request:");
LOG_MESSAGES(errors);
sendErrorResponse(request, error);
return;
}
QString requestId = request["id"].toString();
m_performanceLogger.startTimeMeasurement(requestId);
m_activeRequests[requestId] = {request, provider};
connect(
provider,
&LLMCore::Provider::fullResponseReceived,
provider->client(),
&::LLMCore::BaseClient::requestCompleted,
this,
&LLMClientInterface::handleFullResponse,
Qt::UniqueConnection);
connect(
provider,
&LLMCore::Provider::requestFailed,
provider->client(),
&::LLMCore::BaseClient::requestFailed,
this,
&LLMClientInterface::handleRequestFailed,
Qt::UniqueConnection);
provider->sendRequest(requestId, config.url, config.providerRequest);
auto requestId = provider->sendRequest(config.url, config.providerRequest);
m_activeRequests[requestId] = {request, provider};
m_performanceLogger.startTimeMeasurement(requestId);
}
LLMCore::ContextData LLMClientInterface::prepareContext(
PluginLLMCore::ContextData LLMClientInterface::prepareContext(
const QJsonObject &request, const Context::DocumentInfo &documentInfo)
{
QJsonObject params = request["params"].toObject();
@@ -396,13 +382,13 @@ LLMCore::ContextData LLMClientInterface::prepareContext(
}
QString LLMClientInterface::endpoint(
LLMCore::Provider *provider, LLMCore::TemplateType type, bool isLanguageSpecify)
PluginLLMCore::Provider *provider, PluginLLMCore::TemplateType type, bool isLanguageSpecify)
{
QString endpoint;
auto endpointMode = isLanguageSpecify ? m_generalSettings.ccPreset1EndpointMode.stringValue()
: m_generalSettings.ccEndpointMode.stringValue();
if (endpointMode == "Auto") {
endpoint = type == LLMCore::TemplateType::FIM ? provider->completionEndpoint()
endpoint = type == PluginLLMCore::TemplateType::FIM ? provider->completionEndpoint()
: provider->chatEndpoint();
} else if (endpointMode == "Custom") {
endpoint = isLanguageSpecify ? m_generalSettings.ccPreset1CustomEndpoint()

20
LLMClientInterface.hpp
View File

@@ -25,9 +25,9 @@
#include <context/ContextManager.hpp>
#include <context/IDocumentReader.hpp>
#include <context/ProgrammingLanguage.hpp>
#include <llmcore/ContextData.hpp>
#include <llmcore/IPromptProvider.hpp>
#include <llmcore/IProviderRegistry.hpp>
#include <pluginllmcore/ContextData.hpp>
#include <pluginllmcore/IPromptProvider.hpp>
#include <pluginllmcore/IProviderRegistry.hpp>
#include <logger/IRequestPerformanceLogger.hpp>
#include <settings/CodeCompletionSettings.hpp>
#include <settings/GeneralSettings.hpp>
@@ -45,8 +45,8 @@ public:
LLMClientInterface(
const Settings::GeneralSettings &generalSettings,
const Settings::CodeCompletionSettings &completeSettings,
LLMCore::IProviderRegistry &providerRegistry,
LLMCore::IPromptProvider *promptProvider,
PluginLLMCore::IProviderRegistry &providerRegistry,
PluginLLMCore::IPromptProvider *promptProvider,
Context::IDocumentReader &documentReader,
IRequestPerformanceLogger &performanceLogger);
~LLMClientInterface() override;
@@ -82,17 +82,17 @@ private:
struct RequestContext
{
QJsonObject originalRequest;
LLMCore::Provider *provider;
PluginLLMCore::Provider *provider;
};
LLMCore::ContextData prepareContext(
PluginLLMCore::ContextData prepareContext(
const QJsonObject &request, const Context::DocumentInfo &documentInfo);
QString endpoint(LLMCore::Provider *provider, LLMCore::TemplateType type, bool isLanguageSpecify);
QString endpoint(PluginLLMCore::Provider *provider, PluginLLMCore::TemplateType type, bool isLanguageSpecify);
const Settings::CodeCompletionSettings &m_completeSettings;
const Settings::GeneralSettings &m_generalSettings;
LLMCore::IPromptProvider *m_promptProvider = nullptr;
LLMCore::IProviderRegistry &m_providerRegistry;
PluginLLMCore::IPromptProvider *m_promptProvider = nullptr;
PluginLLMCore::IProviderRegistry &m_providerRegistry;
Context::IDocumentReader &m_documentReader;
IRequestPerformanceLogger &m_performanceLogger;
QElapsedTimer m_completionTimer;

4
QodeAssistClient.hpp
View File

@@ -36,8 +36,8 @@
#include "widgets/EditorChatButtonHandler.hpp"
#include "widgets/RefactorWidgetHandler.hpp"
#include <languageclient/client.h>
#include <llmcore/IPromptProvider.hpp>
#include <llmcore/IProviderRegistry.hpp>
#include <pluginllmcore/IPromptProvider.hpp>
#include <pluginllmcore/IProviderRegistry.hpp>
namespace QodeAssist {

60
QuickRefactorHandler.cpp
View File

@@ -19,18 +19,19 @@
#include "QuickRefactorHandler.hpp"
#include <LLMCore/BaseClient.hpp>
#include <QJsonArray>
#include <QJsonDocument>
#include <QUuid>
#include <context/DocumentContextReader.hpp>
#include <llmcore/ResponseCleaner.hpp>
#include <pluginllmcore/ResponseCleaner.hpp>
#include <context/DocumentReaderQtCreator.hpp>
#include <context/Utils.hpp>
#include <llmcore/PromptTemplateManager.hpp>
#include <llmcore/ProvidersManager.hpp>
#include <llmcore/RequestConfig.hpp>
#include <llmcore/RulesLoader.hpp>
#include <pluginllmcore/PromptTemplateManager.hpp>
#include <pluginllmcore/ProvidersManager.hpp>
#include <pluginllmcore/RequestConfig.hpp>
#include <pluginllmcore/RulesLoader.hpp>
#include <logger/Logger.hpp>
#include <settings/ChatAssistantSettings.hpp>
#include <settings/GeneralSettings.hpp>
@@ -109,8 +110,8 @@ void QuickRefactorHandler::prepareAndSendRequest(
{
auto &settings = Settings::generalSettings();
auto &providerRegistry = LLMCore::ProvidersManager::instance();
auto &promptManager = LLMCore::PromptTemplateManager::instance();
auto &providerRegistry = PluginLLMCore::ProvidersManager::instance();
auto &promptManager = PluginLLMCore::PromptTemplateManager::instance();
const auto providerName = settings.qrProvider();
auto provider = providerRegistry.getProviderByName(providerName);
@@ -140,14 +141,13 @@ void QuickRefactorHandler::prepareAndSendRequest(
return;
}
LLMCore::LLMConfig config;
config.requestType = LLMCore::RequestType::QuickRefactoring;
PluginLLMCore::LLMConfig config;
config.requestType = PluginLLMCore::RequestType::QuickRefactoring;
config.provider = provider;
config.promptTemplate = promptTemplate;
config.url = QString("%1%2").arg(settings.qrUrl(), provider->chatEndpoint());
config.apiKey = provider->apiKey();
if (provider->providerID() == LLMCore::ProviderID::GoogleAI) {
if (provider->providerID() == PluginLLMCore::ProviderID::GoogleAI) {
QString stream = QString{"streamGenerateContent?alt=sse"};
config.url = QUrl(QString("%1/models/%2:%3")
.arg(
@@ -161,7 +161,7 @@ void QuickRefactorHandler::prepareAndSendRequest(
= {{"model", Settings::generalSettings().qrModel()}, {"stream", true}};
}
LLMCore::ContextData context = prepareContext(editor, range, instructions);
PluginLLMCore::ContextData context = prepareContext(editor, range, instructions);
bool enableTools = Settings::quickRefactorSettings().useTools();
bool enableThinking = Settings::quickRefactorSettings().useThinking();
@@ -169,41 +169,39 @@ void QuickRefactorHandler::prepareAndSendRequest(
config.providerRequest,
promptTemplate,
context,
LLMCore::RequestType::QuickRefactoring,
PluginLLMCore::RequestType::QuickRefactoring,
enableTools,
enableThinking);
QString requestId = QUuid::createUuid().toString();
m_lastRequestId = requestId;
QJsonObject request{{"id", requestId}};
m_isRefactoringInProgress = true;
m_activeRequests[requestId] = {request, provider};
connect(
provider,
&LLMCore::Provider::fullResponseReceived,
provider->client(),
&::LLMCore::BaseClient::requestCompleted,
this,
&QuickRefactorHandler::handleFullResponse,
Qt::UniqueConnection);
connect(
provider,
&LLMCore::Provider::requestFailed,
provider->client(),
&::LLMCore::BaseClient::requestFailed,
this,
&QuickRefactorHandler::handleRequestFailed,
Qt::UniqueConnection);
provider->sendRequest(requestId, config.url, config.providerRequest);
auto requestId = provider->sendRequest(config.url, config.providerRequest);
m_lastRequestId = requestId;
QJsonObject request{{"id", requestId}};
m_activeRequests[requestId] = {request, provider};
}
LLMCore::ContextData QuickRefactorHandler::prepareContext(
PluginLLMCore::ContextData QuickRefactorHandler::prepareContext(
TextEditor::TextEditorWidget *editor,
const Utils::Text::Range &range,
const QString &instructions)
{
LLMCore::ContextData context;
PluginLLMCore::ContextData context;
auto textDocument = editor->textDocument();
Context::DocumentReaderQtCreator documentReader;
@@ -287,10 +285,10 @@ LLMCore::ContextData QuickRefactorHandler::prepareContext(
QString systemPrompt = Settings::quickRefactorSettings().systemPrompt();
auto project = LLMCore::RulesLoader::getActiveProject();
auto project = PluginLLMCore::RulesLoader::getActiveProject();
if (project) {
QString projectRules = LLMCore::RulesLoader::loadRulesForProject(
project, LLMCore::RulesContext::QuickRefactor);
QString projectRules = PluginLLMCore::RulesLoader::loadRulesForProject(
project, PluginLLMCore::RulesContext::QuickRefactor);
if (!projectRules.isEmpty()) {
systemPrompt += "\n\n# Project Rules\n\n" + projectRules;
@@ -368,7 +366,7 @@ LLMCore::ContextData QuickRefactorHandler::prepareContext(
context.systemPrompt = systemPrompt;
QVector<LLMCore::Message> messages;
QVector<PluginLLMCore::Message> messages;
messages.append(
{"user",
instructions.isEmpty() ? "Refactor the code to improve its quality and maintainability."
@@ -387,7 +385,7 @@ void QuickRefactorHandler::handleLLMResponse(
if (isComplete) {
m_isRefactoringInProgress = false;
QString cleanedResponse = LLMCore::ResponseCleaner::clean(response);
QString cleanedResponse = PluginLLMCore::ResponseCleaner::clean(response);
RefactorResult result;
result.newText = cleanedResponse;

8
QuickRefactorHandler.hpp
View File

@@ -27,8 +27,8 @@
#include <context/ContextManager.hpp>
#include <context/IDocumentReader.hpp>
#include <llmcore/ContextData.hpp>
#include <llmcore/Provider.hpp>
#include <pluginllmcore/ContextData.hpp>
#include <pluginllmcore/Provider.hpp>
namespace QodeAssist {
@@ -68,7 +68,7 @@ private:
const Utils::Text::Range &range);
void handleLLMResponse(const QString &response, const QJsonObject &request, bool isComplete);
LLMCore::ContextData prepareContext(
PluginLLMCore::ContextData prepareContext(
TextEditor::TextEditorWidget *editor,
const Utils::Text::Range &range,
const QString &instructions);
@@ -76,7 +76,7 @@ private:
struct RequestContext
{
QJsonObject originalRequest;
LLMCore::Provider *provider;
PluginLLMCore::Provider *provider;
};
QHash<QString, RequestContext> m_activeRequests;

2
context/CMakeLists.txt
View File

@@ -20,7 +20,7 @@ target_link_libraries(Context
QtCreator::Utils
QtCreator::ProjectExplorer
PRIVATE
LLMCore
PluginLLMCore
QodeAssistSettings
)

2
context/DocumentContextReader.cpp
View File

@@ -269,7 +269,7 @@ CopyrightInfo DocumentContextReader::copyrightInfo() const
return m_copyrightInfo;
}
LLMCore::ContextData DocumentContextReader::prepareContext(
PluginLLMCore::ContextData DocumentContextReader::prepareContext(
int lineNumber, int cursorPosition, const Settings::CodeCompletionSettings &settings) const
{
QString contextBefore;

4
context/DocumentContextReader.hpp
View File

@@ -22,7 +22,7 @@
#include <texteditor/textdocument.h>
#include <QTextDocument>
#include <llmcore/ContextData.hpp>
#include <pluginllmcore/ContextData.hpp>
#include <settings/CodeCompletionSettings.hpp>
namespace QodeAssist::Context {
@@ -73,7 +73,7 @@ public:
CopyrightInfo copyrightInfo() const;
LLMCore::ContextData prepareContext(
PluginLLMCore::ContextData prepareContext(
int lineNumber, int cursorPosition, const Settings::CodeCompletionSettings &settings) const;
private:

36
llmcore/Provider.cpp
View File

@@ -1,36 +0,0 @@
#include "Provider.hpp"
#include <QJsonDocument>
namespace QodeAssist::LLMCore {
Provider::Provider(QObject *parent)
: QObject(parent)
, m_httpClient(new HttpClient(this))
{
connect(m_httpClient, &HttpClient::dataReceived, this, &Provider::onDataReceived);
connect(m_httpClient, &HttpClient::requestFinished, this, &Provider::onRequestFinished);
}
void Provider::cancelRequest(const RequestID &requestId)
{
m_httpClient->cancelRequest(requestId);
}
HttpClient *Provider::httpClient() const
{
return m_httpClient;
}
QJsonObject Provider::parseEventLine(const QString &line)
{
if (!line.startsWith("data: "))
return QJsonObject();
QString jsonStr = line.mid(6);
QJsonDocument doc = QJsonDocument::fromJson(jsonStr.toUtf8());
return doc.object();
}
} // namespace QodeAssist::LLMCore

118
llmcore/Provider.hpp
View File

@@ -1,118 +0,0 @@
/*
* Copyright (C) 2024-2025 Petr Mironychev
*
* This file is part of QodeAssist.
*
* QodeAssist 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 3 of the License, or
* (at your option) any later version.
*
* QodeAssist 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 QodeAssist. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
#include <optional>
#include <QFuture>
#include <utils/environment.h>
#include <QNetworkRequest>
#include <QObject>
#include <QString>
#include "ContextData.hpp"
#include "DataBuffers.hpp"
#include "HttpClient.hpp"
#include "IToolsManager.hpp"
#include "PromptTemplate.hpp"
#include "RequestType.hpp"
class QNetworkReply;
class QJsonObject;
namespace QodeAssist::LLMCore {
class Provider : public QObject
{
Q_OBJECT
public:
explicit Provider(QObject *parent = nullptr);
virtual ~Provider() = default;
virtual QString name() const = 0;
virtual QString url() const = 0;
virtual QString completionEndpoint() const = 0;
virtual QString chatEndpoint() const = 0;
virtual bool supportsModelListing() const = 0;
virtual void prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
= 0;
virtual QFuture<QList<QString>> getInstalledModels(const QString &url) = 0;
virtual QList<QString> validateRequest(const QJsonObject &request, TemplateType type) = 0;
virtual QString apiKey() const = 0;
virtual void prepareNetworkRequest(QNetworkRequest &networkRequest) const = 0;
virtual ProviderID providerID() const = 0;
virtual void sendRequest(const RequestID &requestId, const QUrl &url, const QJsonObject &payload)
= 0;
virtual bool supportsTools() const { return false; };
virtual bool supportThinking() const { return false; };
virtual bool supportImage() const { return false; };
virtual void cancelRequest(const RequestID &requestId);
virtual IToolsManager *toolsManager() const { return nullptr; }
HttpClient *httpClient() const;
public slots:
virtual void onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data)
= 0;
virtual void onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId, std::optional<QString> error)
= 0;
signals:
void partialResponseReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QString &partialText);
void fullResponseReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QString &fullText);
void requestFailed(const QodeAssist::LLMCore::RequestID &requestId, const QString &error);
void toolExecutionStarted(
const QString &requestId, const QString &toolId, const QString &toolName);
void toolExecutionCompleted(
const QString &requestId,
const QString &toolId,
const QString &toolName,
const QString &result);
void continuationStarted(const QodeAssist::LLMCore::RequestID &requestId);
void thinkingBlockReceived(
const QString &requestId, const QString &thinking, const QString &signature);
void redactedThinkingBlockReceived(const QString &requestId, const QString &signature);
protected:
QJsonObject parseEventLine(const QString &line);
QHash<RequestID, DataBuffers> m_dataBuffers;
QHash<RequestID, QUrl> m_requestUrls;
private:
HttpClient *m_httpClient;
};
} // namespace QodeAssist::LLMCore

57
llmcore/ValidationUtils.cpp
View File

@@ -1,57 +0,0 @@
/*
* Copyright (C) 2024-2025 Petr Mironychev
*
* This file is part of QodeAssist.
*
* QodeAssist 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 3 of the License, or
* (at your option) any later version.
*
* QodeAssist 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 QodeAssist. If not, see <https://www.gnu.org/licenses/>.
*/
#include "ValidationUtils.hpp"
#include <QJsonArray>
namespace QodeAssist::LLMCore {
QStringList ValidationUtils::validateRequestFields(
const QJsonObject &request, const QJsonObject &templateObj)
{
QStringList errors;
validateFields(request, templateObj, errors);
validateNestedObjects(request, templateObj, errors);
return errors;
}
void ValidationUtils::validateFields(
const QJsonObject &request, const QJsonObject &templateObj, QStringList &errors)
{
for (auto it = request.begin(); it != request.end(); ++it) {
if (!templateObj.contains(it.key())) {
errors << QString("unknown field '%1'").arg(it.key());
}
}
}
void ValidationUtils::validateNestedObjects(
const QJsonObject &request, const QJsonObject &templateObj, QStringList &errors)
{
for (auto it = request.begin(); it != request.end(); ++it) {
if (templateObj.contains(it.key()) && it.value().isObject()
&& templateObj[it.key()].isObject()) {
validateFields(it.value().toObject(), templateObj[it.key()].toObject(), errors);
validateNestedObjects(it.value().toObject(), templateObj[it.key()].toObject(), errors);
}
}
}
} // namespace QodeAssist::LLMCore

4
llmcore/BaseTool.cpp → pluginllmcore/BaseTool.cpp
View File

@@ -19,7 +19,7 @@
#include "BaseTool.hpp"
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
BaseTool::BaseTool(QObject *parent)
: QObject(parent)
@@ -70,4 +70,4 @@ QJsonObject BaseTool::customizeForGoogle(const QJsonObject &baseDefinition) cons
return tool;
}
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/BaseTool.hpp → pluginllmcore/BaseTool.hpp
View File

@@ -25,7 +25,7 @@
#include <QObject>
#include <QString>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
enum class ToolSchemaFormat { OpenAI, Claude, Ollama, Google };
@@ -67,4 +67,4 @@ protected:
virtual QJsonObject customizeForGoogle(const QJsonObject &baseDefinition) const;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

8
llmcore/CMakeLists.txt → pluginllmcore/CMakeLists.txt
View File

@@ -1,4 +1,4 @@
add_library(LLMCore STATIC
add_library(PluginLLMCore STATIC
RequestType.hpp
Provider.hpp Provider.cpp
ProvidersManager.hpp ProvidersManager.cpp
@@ -10,7 +10,6 @@ add_library(LLMCore STATIC
PromptTemplate.hpp
PromptTemplateManager.hpp PromptTemplateManager.cpp
RequestConfig.hpp
ValidationUtils.hpp ValidationUtils.cpp
ProviderID.hpp
HttpClient.hpp HttpClient.cpp
DataBuffers.hpp
@@ -21,15 +20,16 @@ add_library(LLMCore STATIC
ResponseCleaner.hpp
)
target_link_libraries(LLMCore
target_link_libraries(PluginLLMCore
PUBLIC
Qt::Core
Qt::Network
QtCreator::Core
QtCreator::Utils
QtCreator::ExtensionSystem
LLMCore
PRIVATE
QodeAssistLogger
)
target_include_directories(LLMCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_include_directories(PluginLLMCore PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

4
llmcore/ContentBlocks.hpp → pluginllmcore/ContentBlocks.hpp
View File

@@ -26,7 +26,7 @@
#include <QObject>
#include <QString>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
enum class MessageState { Building, Complete, RequiresToolExecution, Final };
@@ -249,4 +249,4 @@ private:
QString m_signature;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/ContextData.hpp → pluginllmcore/ContextData.hpp
View File

@@ -22,7 +22,7 @@
#include <QString>
#include <QVector>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
struct ImageAttachment
{
@@ -66,4 +66,4 @@ struct ContextData
bool operator==(const ContextData &) const = default;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/DataBuffers.hpp → pluginllmcore/DataBuffers.hpp
View File

@@ -22,7 +22,7 @@
#include "SSEBuffer.hpp"
#include <QString>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
struct DataBuffers
{
@@ -36,4 +36,4 @@ struct DataBuffers
}
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/HttpClient.cpp → pluginllmcore/HttpClient.cpp
View File

@@ -24,7 +24,7 @@
#include <Logger.hpp>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
HttpClient::HttpClient(QObject *parent)
: QObject(parent)
@@ -273,4 +273,4 @@ QString HttpClient::parseErrorFromResponse(
return QString("HTTP %1: %2").arg(statusCode).arg(networkErrorString);
}
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/HttpClient.hpp → pluginllmcore/HttpClient.hpp
View File

@@ -30,7 +30,7 @@
#include <QObject>
#include <QPromise>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class HttpClient : public QObject
{
@@ -73,4 +73,4 @@ private:
mutable QMutex m_mutex;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/IPromptProvider.hpp → pluginllmcore/IPromptProvider.hpp
View File

@@ -22,7 +22,7 @@
#include "PromptTemplate.hpp"
#include <QString>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class IPromptProvider
{
@@ -36,4 +36,4 @@ public:
virtual QStringList getTemplatesForProvider(ProviderID id) const = 0;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/IProviderRegistry.hpp → pluginllmcore/IProviderRegistry.hpp
View File

@@ -21,7 +21,7 @@
#include "Provider.hpp"
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class IProviderRegistry
{
@@ -33,4 +33,4 @@ public:
virtual QStringList providersNames() const = 0;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

2
llmcore/IToolsManager.hpp → pluginllmcore/IToolsManager.hpp
View File

@@ -26,7 +26,7 @@
#include "BaseTool.hpp"
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class IToolsManager
{

4
llmcore/PromptProviderChat.hpp → pluginllmcore/PromptProviderChat.hpp
View File

@@ -23,7 +23,7 @@
#include "PromptTemplate.hpp"
#include "PromptTemplateManager.hpp"
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class PromptProviderChat : public IPromptProvider
{
@@ -50,4 +50,4 @@ private:
PromptTemplateManager &m_templateManager;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/PromptProviderFim.hpp → pluginllmcore/PromptProviderFim.hpp
View File

@@ -22,7 +22,7 @@
#include "IPromptProvider.hpp"
#include "PromptTemplateManager.hpp"
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class PromptProviderFim : public IPromptProvider
{
@@ -49,4 +49,4 @@ private:
PromptTemplateManager &m_templateManager;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/PromptTemplate.hpp → pluginllmcore/PromptTemplate.hpp
View File

@@ -26,7 +26,7 @@
#include "ContextData.hpp"
#include "ProviderID.hpp"
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
enum class TemplateType { Chat, FIM, FIMOnChat };
@@ -41,4 +41,4 @@ public:
virtual QString description() const = 0;
virtual bool isSupportProvider(ProviderID id) const = 0;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/PromptTemplateManager.cpp → pluginllmcore/PromptTemplateManager.cpp
View File

@@ -21,7 +21,7 @@
#include <QMessageBox>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
PromptTemplateManager &PromptTemplateManager::instance()
{
@@ -96,4 +96,4 @@ PromptTemplate *PromptTemplateManager::getChatTemplateByName(const QString &temp
return m_chatTemplates[templateName];
}
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/PromptTemplateManager.hpp → pluginllmcore/PromptTemplateManager.hpp
View File

@@ -24,7 +24,7 @@
#include "PromptTemplate.hpp"
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class PromptTemplateManager
{
@@ -62,4 +62,4 @@ private:
QMap<QString, PromptTemplate *> m_chatTemplates;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

61
pluginllmcore/Provider.cpp Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright (C) 2024-2025 Petr Mironychev
*
* This file is part of QodeAssist.
*
* QodeAssist 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 3 of the License, or
* (at your option) any later version.
*
* QodeAssist 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 QodeAssist. If not, see <https://www.gnu.org/licenses/>.
*/
#include "Provider.hpp"
#include <LLMCore/BaseClient.hpp>
#include <LLMCore/ToolsManager.hpp>
#include <Logger.hpp>
namespace QodeAssist::PluginLLMCore {
Provider::Provider(QObject *parent)
: QObject(parent)
{}
RequestID Provider::sendRequest(const QUrl &url, const QJsonObject &payload)
{
auto *c = client();
QUrl baseUrl(url);
baseUrl.setPath("");
c->setUrl(baseUrl.toString());
c->setApiKey(apiKey());
auto requestId = c->sendMessage(payload);
LOG_MESSAGE(
QString("%1: Sending request %2 to %3").arg(name(), requestId, url.toString()));
return requestId;
}
void Provider::cancelRequest(const RequestID &requestId)
{
LOG_MESSAGE(QString("%1: Cancelling request %2").arg(name(), requestId));
client()->cancelRequest(requestId);
}
::LLMCore::ToolsManager *Provider::toolsManager() const
{
return client()->tools();
}
} // namespace QodeAssist::PluginLLMCore

83
pluginllmcore/Provider.hpp Normal file
View File

@@ -0,0 +1,83 @@
/*
* Copyright (C) 2024-2025 Petr Mironychev
*
* This file is part of QodeAssist.
*
* QodeAssist 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 3 of the License, or
* (at your option) any later version.
*
* QodeAssist 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 QodeAssist. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
#include <QFlags>
#include <QFuture>
#include <QObject>
#include <QString>
#include <utils/environment.h>
#include "ContextData.hpp"
#include "IToolsManager.hpp"
#include "PromptTemplate.hpp"
#include "RequestType.hpp"
namespace LLMCore {
class BaseClient;
class ToolsManager;
}
class QJsonObject;
namespace QodeAssist::PluginLLMCore {
enum class ProviderCapability {
Tools = 0x1,
Thinking = 0x2,
Image = 0x4,
ModelListing = 0x8,
};
Q_DECLARE_FLAGS(ProviderCapabilities, ProviderCapability)
Q_DECLARE_OPERATORS_FOR_FLAGS(ProviderCapabilities)
class Provider : public QObject
{
Q_OBJECT
public:
explicit Provider(QObject *parent = nullptr);
virtual ~Provider() = default;
virtual QString name() const = 0;
virtual QString url() const = 0;
virtual QString completionEndpoint() const = 0;
virtual QString chatEndpoint() const = 0;
virtual void prepareRequest(
QJsonObject &request,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
= 0;
virtual QFuture<QList<QString>> getInstalledModels(const QString &url) = 0;
virtual ProviderID providerID() const = 0;
virtual ProviderCapabilities capabilities() const { return {}; }
virtual ::LLMCore::BaseClient *client() const = 0;
virtual QString apiKey() const = 0;
RequestID sendRequest(const QUrl &url, const QJsonObject &payload);
void cancelRequest(const RequestID &requestId);
::LLMCore::ToolsManager *toolsManager() const;
};
} // namespace QodeAssist::PluginLLMCore

2
llmcore/ProviderID.hpp → pluginllmcore/ProviderID.hpp
View File

@@ -17,7 +17,7 @@
* along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
*/
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
enum class ProviderID {
Any,

4
llmcore/ProvidersManager.cpp → pluginllmcore/ProvidersManager.cpp
View File

@@ -19,7 +19,7 @@
#include "ProvidersManager.hpp"
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
ProvidersManager &ProvidersManager::instance()
{
@@ -44,4 +44,4 @@ Provider *ProvidersManager::getProviderByName(const QString &providerName)
return m_providers[providerName];
}
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/ProvidersManager.hpp → pluginllmcore/ProvidersManager.hpp
View File

@@ -24,7 +24,7 @@
#include "IProviderRegistry.hpp"
#include <QMap>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class ProvidersManager : public IProviderRegistry
{
@@ -53,4 +53,4 @@ private:
QMap<QString, Provider *> m_providers;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

5
llmcore/RequestConfig.hpp → pluginllmcore/RequestConfig.hpp
View File

@@ -25,7 +25,7 @@
#include <QJsonObject>
#include <QUrl>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
struct LLMConfig
{
@@ -35,7 +35,6 @@ struct LLMConfig
QJsonObject providerRequest;
RequestType requestType;
bool multiLineCompletion;
QString apiKey;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

0
llmcore/RequestHandlerBase.cpp → pluginllmcore/RequestHandlerBase.cpp
View File

0
llmcore/RequestHandlerBase.hpp → pluginllmcore/RequestHandlerBase.hpp
View File

2
llmcore/RequestType.hpp → pluginllmcore/RequestType.hpp
View File

@@ -21,7 +21,7 @@
#pragma once
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
enum RequestType { CodeCompletion, Chat, Embedding, QuickRefactoring };

4
llmcore/ResponseCleaner.hpp → pluginllmcore/ResponseCleaner.hpp
View File

@@ -23,7 +23,7 @@
#include <QStringList>
#include <QRegularExpression>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class ResponseCleaner
{
@@ -115,5 +115,5 @@ private:
}
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/RulesLoader.cpp → pluginllmcore/RulesLoader.cpp
View File

@@ -26,7 +26,7 @@
#include <projectexplorer/project.h>
#include <projectexplorer/projectmanager.h>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
QString RulesLoader::loadRules(const QString &projectPath, RulesContext context)
{
@@ -178,4 +178,4 @@ QVector<RuleFileInfo> RulesLoader::collectMarkdownFiles(
return result;
}
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/RulesLoader.hpp → pluginllmcore/RulesLoader.hpp
View File

@@ -25,7 +25,7 @@ namespace ProjectExplorer {
class Project;
}
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
enum class RulesContext { Completions, Chat, QuickRefactor };
@@ -54,4 +54,4 @@ private:
static QString getProjectPath(ProjectExplorer::Project *project);
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/SSEBuffer.cpp → pluginllmcore/SSEBuffer.cpp
View File

@@ -19,7 +19,7 @@
#include "SSEBuffer.hpp"
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
QStringList SSEBuffer::processData(const QByteArray &data)
{
@@ -48,4 +48,4 @@ bool SSEBuffer::hasIncompleteData() const
return !m_buffer.isEmpty();
}
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

4
llmcore/SSEBuffer.hpp → pluginllmcore/SSEBuffer.hpp
View File

@@ -22,7 +22,7 @@
#include <QString>
#include <QStringList>
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class SSEBuffer
{
@@ -39,4 +39,4 @@ private:
QString m_buffer;
};
} // namespace QodeAssist::LLMCore
} // namespace QodeAssist::PluginLLMCore

58
providers/ClaudeMessage.cpp
View File

@@ -37,32 +37,32 @@ void ClaudeMessage::handleContentBlockStart(
.arg(blockType));
if (blockType == "text") {
addCurrentContent<LLMCore::TextContent>();
addCurrentContent<PluginLLMCore::TextContent>();
} else if (blockType == "image") {
QJsonObject source = data["source"].toObject();
QString sourceType = source["type"].toString();
QString imageData;
QString mediaType;
LLMCore::ImageContent::ImageSourceType imgSourceType = LLMCore::ImageContent::ImageSourceType::Base64;
PluginLLMCore::ImageContent::ImageSourceType imgSourceType = PluginLLMCore::ImageContent::ImageSourceType::Base64;
if (sourceType == "base64") {
imageData = source["data"].toString();
mediaType = source["media_type"].toString();
imgSourceType = LLMCore::ImageContent::ImageSourceType::Base64;
imgSourceType = PluginLLMCore::ImageContent::ImageSourceType::Base64;
} else if (sourceType == "url") {
imageData = source["url"].toString();
imgSourceType = LLMCore::ImageContent::ImageSourceType::Url;
imgSourceType = PluginLLMCore::ImageContent::ImageSourceType::Url;
}
addCurrentContent<LLMCore::ImageContent>(imageData, mediaType, imgSourceType);
addCurrentContent<PluginLLMCore::ImageContent>(imageData, mediaType, imgSourceType);
} else if (blockType == "tool_use") {
QString toolId = data["id"].toString();
QString toolName = data["name"].toString();
QJsonObject toolInput = data["input"].toObject();
addCurrentContent<LLMCore::ToolUseContent>(toolId, toolName, toolInput);
addCurrentContent<PluginLLMCore::ToolUseContent>(toolId, toolName, toolInput);
m_pendingToolInputs[index] = "";
} else if (blockType == "thinking") {
@@ -70,13 +70,13 @@ void ClaudeMessage::handleContentBlockStart(
QString signature = data["signature"].toString();
LOG_MESSAGE(QString("ClaudeMessage: Creating thinking block with signature length=%1")
.arg(signature.length()));
addCurrentContent<LLMCore::ThinkingContent>(thinking, signature);
addCurrentContent<PluginLLMCore::ThinkingContent>(thinking, signature);
} else if (blockType == "redacted_thinking") {
QString signature = data["signature"].toString();
LOG_MESSAGE(QString("ClaudeMessage: Creating redacted_thinking block with signature length=%1")
.arg(signature.length()));
addCurrentContent<LLMCore::RedactedThinkingContent>(signature);
addCurrentContent<PluginLLMCore::RedactedThinkingContent>(signature);
}
}
@@ -88,7 +88,7 @@ void ClaudeMessage::handleContentBlockDelta(
}
if (deltaType == "text_delta") {
if (auto textContent = qobject_cast<LLMCore::TextContent *>(m_currentBlocks[index])) {
if (auto textContent = qobject_cast<PluginLLMCore::TextContent *>(m_currentBlocks[index])) {
textContent->appendText(delta["text"].toString());
}
@@ -99,17 +99,17 @@ void ClaudeMessage::handleContentBlockDelta(
}
} else if (deltaType == "thinking_delta") {
if (auto thinkingContent = qobject_cast<LLMCore::ThinkingContent *>(m_currentBlocks[index])) {
if (auto thinkingContent = qobject_cast<PluginLLMCore::ThinkingContent *>(m_currentBlocks[index])) {
thinkingContent->appendThinking(delta["thinking"].toString());
}
} else if (deltaType == "signature_delta") {
if (auto thinkingContent = qobject_cast<LLMCore::ThinkingContent *>(m_currentBlocks[index])) {
if (auto thinkingContent = qobject_cast<PluginLLMCore::ThinkingContent *>(m_currentBlocks[index])) {
QString signature = delta["signature"].toString();
thinkingContent->setSignature(signature);
LOG_MESSAGE(QString("Set signature for thinking block %1: length=%2")
.arg(index).arg(signature.length()));
} else if (auto redactedContent = qobject_cast<LLMCore::RedactedThinkingContent *>(m_currentBlocks[index])) {
} else if (auto redactedContent = qobject_cast<PluginLLMCore::RedactedThinkingContent *>(m_currentBlocks[index])) {
QString signature = delta["signature"].toString();
redactedContent->setSignature(signature);
LOG_MESSAGE(QString("Set signature for redacted_thinking block %1: length=%2")
@@ -132,7 +132,7 @@ void ClaudeMessage::handleContentBlockStop(int index)
}
if (index < m_currentBlocks.size()) {
if (auto toolContent = qobject_cast<LLMCore::ToolUseContent *>(m_currentBlocks[index])) {
if (auto toolContent = qobject_cast<PluginLLMCore::ToolUseContent *>(m_currentBlocks[index])) {
toolContent->setInput(inputObject);
}
}
@@ -155,7 +155,7 @@ QJsonObject ClaudeMessage::toProviderFormat() const
QJsonArray content;
for (auto block : m_currentBlocks) {
QJsonValue blockJson = block->toJson(LLMCore::ProviderFormat::Claude);
QJsonValue blockJson = block->toJson(PluginLLMCore::ProviderFormat::Claude);
content.append(blockJson);
}
@@ -173,42 +173,42 @@ QJsonArray ClaudeMessage::createToolResultsContent(const QHash<QString, QString>
for (auto toolContent : getCurrentToolUseContent()) {
if (toolResults.contains(toolContent->id())) {
auto toolResult = std::make_unique<LLMCore::ToolResultContent>(
auto toolResult = std::make_unique<PluginLLMCore::ToolResultContent>(
toolContent->id(), toolResults[toolContent->id()]);
results.append(toolResult->toJson(LLMCore::ProviderFormat::Claude));
results.append(toolResult->toJson(PluginLLMCore::ProviderFormat::Claude));
}
}
return results;
}
QList<LLMCore::ToolUseContent *> ClaudeMessage::getCurrentToolUseContent() const
QList<PluginLLMCore::ToolUseContent *> ClaudeMessage::getCurrentToolUseContent() const
{
QList<LLMCore::ToolUseContent *> toolBlocks;
QList<PluginLLMCore::ToolUseContent *> toolBlocks;
for (auto block : m_currentBlocks) {
if (auto toolContent = qobject_cast<LLMCore::ToolUseContent *>(block)) {
if (auto toolContent = qobject_cast<PluginLLMCore::ToolUseContent *>(block)) {
toolBlocks.append(toolContent);
}
}
return toolBlocks;
}
QList<LLMCore::ThinkingContent *> ClaudeMessage::getCurrentThinkingContent() const
QList<PluginLLMCore::ThinkingContent *> ClaudeMessage::getCurrentThinkingContent() const
{
QList<LLMCore::ThinkingContent *> thinkingBlocks;
QList<PluginLLMCore::ThinkingContent *> thinkingBlocks;
for (auto block : m_currentBlocks) {
if (auto thinkingContent = qobject_cast<LLMCore::ThinkingContent *>(block)) {
if (auto thinkingContent = qobject_cast<PluginLLMCore::ThinkingContent *>(block)) {
thinkingBlocks.append(thinkingContent);
}
}
return thinkingBlocks;
}
QList<LLMCore::RedactedThinkingContent *> ClaudeMessage::getCurrentRedactedThinkingContent() const
QList<PluginLLMCore::RedactedThinkingContent *> ClaudeMessage::getCurrentRedactedThinkingContent() const
{
QList<LLMCore::RedactedThinkingContent *> redactedBlocks;
QList<PluginLLMCore::RedactedThinkingContent *> redactedBlocks;
for (auto block : m_currentBlocks) {
if (auto redactedContent = qobject_cast<LLMCore::RedactedThinkingContent *>(block)) {
if (auto redactedContent = qobject_cast<PluginLLMCore::RedactedThinkingContent *>(block)) {
redactedBlocks.append(redactedContent);
}
}
@@ -222,17 +222,17 @@ void ClaudeMessage::startNewContinuation()
m_currentBlocks.clear();
m_pendingToolInputs.clear();
m_stopReason.clear();
m_state = LLMCore::MessageState::Building;
m_state = PluginLLMCore::MessageState::Building;
}
void ClaudeMessage::updateStateFromStopReason()
{
if (m_stopReason == "tool_use" && !getCurrentToolUseContent().empty()) {
m_state = LLMCore::MessageState::RequiresToolExecution;
m_state = PluginLLMCore::MessageState::RequiresToolExecution;
} else if (m_stopReason == "end_turn") {
m_state = LLMCore::MessageState::Final;
m_state = PluginLLMCore::MessageState::Final;
} else {
m_state = LLMCore::MessageState::Complete;
m_state = PluginLLMCore::MessageState::Complete;
}
}

16
providers/ClaudeMessage.hpp
View File

@@ -19,7 +19,7 @@
#pragma once
#include <llmcore/ContentBlocks.hpp>
#include <pluginllmcore/ContentBlocks.hpp>
namespace QodeAssist {
@@ -37,18 +37,18 @@ public:
QJsonObject toProviderFormat() const;
QJsonArray createToolResultsContent(const QHash<QString, QString> &toolResults) const;
LLMCore::MessageState state() const { return m_state; }
QList<LLMCore::ToolUseContent *> getCurrentToolUseContent() const;
QList<LLMCore::ThinkingContent *> getCurrentThinkingContent() const;
QList<LLMCore::RedactedThinkingContent *> getCurrentRedactedThinkingContent() const;
const QList<LLMCore::ContentBlock *> &getCurrentBlocks() const { return m_currentBlocks; }
PluginLLMCore::MessageState state() const { return m_state; }
QList<PluginLLMCore::ToolUseContent *> getCurrentToolUseContent() const;
QList<PluginLLMCore::ThinkingContent *> getCurrentThinkingContent() const;
QList<PluginLLMCore::RedactedThinkingContent *> getCurrentRedactedThinkingContent() const;
const QList<PluginLLMCore::ContentBlock *> &getCurrentBlocks() const { return m_currentBlocks; }
void startNewContinuation();
private:
QString m_stopReason;
LLMCore::MessageState m_state = LLMCore::MessageState::Building;
QList<LLMCore::ContentBlock *> m_currentBlocks;
PluginLLMCore::MessageState m_state = PluginLLMCore::MessageState::Building;
QList<PluginLLMCore::ContentBlock *> m_currentBlocks;
QHash<int, QString> m_pendingToolInputs;
void updateStateFromStopReason();

445
providers/ClaudeProvider.cpp
View File

@@ -22,27 +22,24 @@
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QUrlQuery>
#include "llmcore/ValidationUtils.hpp"
#include <LLMCore/ToolsManager.hpp>
#include "logger/Logger.hpp"
#include "settings/ChatAssistantSettings.hpp"
#include "settings/CodeCompletionSettings.hpp"
#include "settings/QuickRefactorSettings.hpp"
#include "settings/GeneralSettings.hpp"
#include "settings/ProviderSettings.hpp"
#include "tools/ToolsRegistration.hpp"
namespace QodeAssist::Providers {
ClaudeProvider::ClaudeProvider(QObject *parent)
: LLMCore::Provider(parent)
, m_toolsManager(new Tools::ToolsManager(this))
: PluginLLMCore::Provider(parent)
, m_client(new ::LLMCore::ClaudeClient(QString(), QString(), QString(), this))
{
connect(
m_toolsManager,
&Tools::ToolsManager::toolExecutionComplete,
this,
&ClaudeProvider::onToolExecutionComplete);
Tools::registerQodeAssistTools(m_client->tools());
}
QString ClaudeProvider::name() const
@@ -50,6 +47,11 @@ QString ClaudeProvider::name() const
return "Claude";
}
QString ClaudeProvider::apiKey() const
{
return Settings::providerSettings().claudeApiKey();
}
QString ClaudeProvider::url() const
{
return "https://api.anthropic.com";
@@ -65,16 +67,11 @@ QString ClaudeProvider::chatEndpoint() const
return "/v1/messages";
}
bool ClaudeProvider::supportsModelListing() const
{
return true;
}
void ClaudeProvider::prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
{
@@ -102,10 +99,10 @@ void ClaudeProvider::prepareRequest(
request["temperature"] = 1.0;
};
if (type == LLMCore::RequestType::CodeCompletion) {
if (type == PluginLLMCore::RequestType::CodeCompletion) {
applyModelParams(Settings::codeCompletionSettings());
request["temperature"] = Settings::codeCompletionSettings().temperature();
} else if (type == LLMCore::RequestType::QuickRefactoring) {
} else if (type == PluginLLMCore::RequestType::QuickRefactoring) {
const auto &qrSettings = Settings::quickRefactorSettings();
applyModelParams(qrSettings);
@@ -126,13 +123,8 @@ void ClaudeProvider::prepareRequest(
}
if (isToolsEnabled) {
LLMCore::RunToolsFilter filter = LLMCore::RunToolsFilter::ALL;
if (type == LLMCore::RequestType::QuickRefactoring) {
filter = LLMCore::RunToolsFilter::OnlyRead;
}
auto toolsDefinitions = m_client->tools()->getToolsDefinitions();
auto toolsDefinitions = m_toolsManager->getToolsDefinitions(
LLMCore::ToolSchemaFormat::Claude, filter);
if (!toolsDefinitions.isEmpty()) {
request["tools"] = toolsDefinitions;
LOG_MESSAGE(QString("Added %1 tools to Claude request").arg(toolsDefinitions.size()));
@@ -142,407 +134,26 @@ void ClaudeProvider::prepareRequest(
QFuture<QList<QString>> ClaudeProvider::getInstalledModels(const QString &baseUrl)
{
QUrl url(baseUrl + "/v1/models");
QUrlQuery query;
query.addQueryItem("limit", "1000");
url.setQuery(query);
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
request.setRawHeader("anthropic-version", "2023-06-01");
if (!apiKey().isEmpty()) {
request.setRawHeader("x-api-key", apiKey().toUtf8());
m_client->setUrl(baseUrl);
m_client->setApiKey(apiKey());
return m_client->listModels();
}
return httpClient()->get(request).then([](const QByteArray &data) {
QList<QString> models;
QJsonObject jsonObject = QJsonDocument::fromJson(data).object();
if (jsonObject.contains("data")) {
QJsonArray modelArray = jsonObject["data"].toArray();
for (const QJsonValue &value : modelArray) {
QJsonObject modelObject = value.toObject();
if (modelObject.contains("id")) {
models.append(modelObject["id"].toString());
}
}
}
return models;
}).onFailed([](const std::exception &e) {
LOG_MESSAGE(QString("Error fetching Claude models: %1").arg(e.what()));
return QList<QString>{};
});
}
QList<QString> ClaudeProvider::validateRequest(const QJsonObject &request, LLMCore::TemplateType type)
PluginLLMCore::ProviderID ClaudeProvider::providerID() const
{
const auto templateReq = QJsonObject{
{"model", {}},
{"system", {}},
{"messages", QJsonArray{{QJsonObject{{"role", {}}, {"content", {}}}}}},
{"temperature", {}},
{"max_tokens", {}},
{"anthropic-version", {}},
{"top_p", {}},
{"top_k", {}},
{"stop", QJsonArray{}},
{"stream", {}},
{"tools", {}},
{"thinking", QJsonObject{{"type", {}}, {"budget_tokens", {}}}}};
return LLMCore::ValidationUtils::validateRequestFields(request, templateReq);
return PluginLLMCore::ProviderID::Claude;
}
QString ClaudeProvider::apiKey() const
PluginLLMCore::ProviderCapabilities ClaudeProvider::capabilities() const
{
return Settings::providerSettings().claudeApiKey();
return PluginLLMCore::ProviderCapability::Tools | PluginLLMCore::ProviderCapability::Thinking
| PluginLLMCore::ProviderCapability::Image
| PluginLLMCore::ProviderCapability::ModelListing;
}
void ClaudeProvider::prepareNetworkRequest(QNetworkRequest &networkRequest) const
::LLMCore::BaseClient *ClaudeProvider::client() const
{
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
networkRequest.setRawHeader("anthropic-version", "2023-06-01");
if (!apiKey().isEmpty()) {
networkRequest.setRawHeader("x-api-key", apiKey().toUtf8());
}
}
LLMCore::ProviderID ClaudeProvider::providerID() const
{
return LLMCore::ProviderID::Claude;
}
void ClaudeProvider::sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload)
{
if (!m_messages.contains(requestId)) {
m_dataBuffers[requestId].clear();
}
m_requestUrls[requestId] = url;
m_originalRequests[requestId] = payload;
QNetworkRequest networkRequest(url);
prepareNetworkRequest(networkRequest);
LOG_MESSAGE(QString("ClaudeProvider: Sending request %1 to %2").arg(requestId, url.toString()));
httpClient()->postStreaming(requestId, networkRequest, payload);
}
bool ClaudeProvider::supportsTools() const
{
return true;
}
bool ClaudeProvider::supportThinking() const {
return true;
};
bool ClaudeProvider::supportImage() const {
return true;
};
void ClaudeProvider::cancelRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("ClaudeProvider: Cancelling request %1").arg(requestId));
LLMCore::Provider::cancelRequest(requestId);
cleanupRequest(requestId);
}
LLMCore::IToolsManager *ClaudeProvider::toolsManager() const
{
return m_toolsManager;
}
void ClaudeProvider::onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data)
{
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
QStringList lines = buffers.rawStreamBuffer.processData(data);
for (const QString &line : lines) {
QJsonObject responseObj = parseEventLine(line);
if (responseObj.isEmpty())
continue;
processStreamEvent(requestId, responseObj);
}
}
void ClaudeProvider::onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId, std::optional<QString> error)
{
if (error) {
LOG_MESSAGE(QString("ClaudeProvider request %1 failed: %2").arg(requestId, *error));
emit requestFailed(requestId, *error);
cleanupRequest(requestId);
return;
}
if (m_messages.contains(requestId)) {
ClaudeMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Waiting for tools to complete for %1").arg(requestId));
m_dataBuffers.remove(requestId);
return;
}
}
if (m_dataBuffers.contains(requestId)) {
const LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
if (!buffers.responseContent.isEmpty()) {
LOG_MESSAGE(QString("Emitting full response for %1").arg(requestId));
emit fullResponseReceived(requestId, buffers.responseContent);
}
}
cleanupRequest(requestId);
}
void ClaudeProvider::onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults)
{
if (!m_messages.contains(requestId) || !m_requestUrls.contains(requestId)) {
LOG_MESSAGE(QString("ERROR: Missing data for continuation request %1").arg(requestId));
cleanupRequest(requestId);
return;
}
LOG_MESSAGE(QString("Tool execution complete for Claude request %1").arg(requestId));
for (auto it = toolResults.begin(); it != toolResults.end(); ++it) {
ClaudeMessage *message = m_messages[requestId];
auto toolContent = message->getCurrentToolUseContent();
for (auto tool : toolContent) {
if (tool->id() == it.key()) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(tool->name());
emit toolExecutionCompleted(
requestId, tool->id(), toolStringName, toolResults[tool->id()]);
break;
}
}
}
ClaudeMessage *message = m_messages[requestId];
QJsonObject continuationRequest = m_originalRequests[requestId];
QJsonArray messages = continuationRequest["messages"].toArray();
messages.append(message->toProviderFormat());
QJsonObject userMessage;
userMessage["role"] = "user";
userMessage["content"] = message->createToolResultsContent(toolResults);
messages.append(userMessage);
continuationRequest["messages"] = messages;
if (continuationRequest.contains("thinking")) {
QJsonObject thinkingObj = continuationRequest["thinking"].toObject();
LOG_MESSAGE(QString("Thinking mode preserved for continuation: type=%1, budget=%2 tokens")
.arg(thinkingObj["type"].toString())
.arg(thinkingObj["budget_tokens"].toInt()));
}
LOG_MESSAGE(QString("Sending continuation request for %1 with %2 tool results")
.arg(requestId)
.arg(toolResults.size()));
sendRequest(requestId, m_requestUrls[requestId], continuationRequest);
}
void ClaudeProvider::processStreamEvent(const QString &requestId, const QJsonObject &event)
{
QString eventType = event["type"].toString();
if (eventType == "message_stop") {
return;
}
ClaudeMessage *message = m_messages.value(requestId);
if (!message) {
if (eventType == "message_start") {
message = new ClaudeMessage(this);
m_messages[requestId] = message;
LOG_MESSAGE(QString("Created NEW ClaudeMessage for request %1").arg(requestId));
} else {
return;
}
}
if (eventType == "message_start") {
message->startNewContinuation();
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Starting NEW continuation for request %1").arg(requestId));
} else if (eventType == "content_block_start") {
int index = event["index"].toInt();
QJsonObject contentBlock = event["content_block"].toObject();
QString blockType = contentBlock["type"].toString();
LOG_MESSAGE(
QString("Adding new content block: type=%1, index=%2").arg(blockType).arg(index));
if (blockType == "thinking" || blockType == "redacted_thinking") {
QJsonDocument eventDoc(event);
LOG_MESSAGE(QString("content_block_start event for %1: %2")
.arg(blockType)
.arg(QString::fromUtf8(eventDoc.toJson(QJsonDocument::Compact))));
}
message->handleContentBlockStart(index, blockType, contentBlock);
} else if (eventType == "content_block_delta") {
int index = event["index"].toInt();
QJsonObject delta = event["delta"].toObject();
QString deltaType = delta["type"].toString();
message->handleContentBlockDelta(index, deltaType, delta);
if (deltaType == "text_delta") {
QString text = delta["text"].toString();
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
buffers.responseContent += text;
emit partialResponseReceived(requestId, text);
} else if (deltaType == "signature_delta") {
QString signature = delta["signature"].toString();
}
} else if (eventType == "content_block_stop") {
int index = event["index"].toInt();
auto allBlocks = message->getCurrentBlocks();
if (index < allBlocks.size()) {
QString blockType = allBlocks[index]->type();
if (blockType == "thinking" || blockType == "redacted_thinking") {
QJsonDocument eventDoc(event);
LOG_MESSAGE(QString("content_block_stop event for %1 at index %2: %3")
.arg(blockType)
.arg(index)
.arg(QString::fromUtf8(eventDoc.toJson(QJsonDocument::Compact))));
}
}
if (event.contains("content_block")) {
QJsonObject contentBlock = event["content_block"].toObject();
QString blockType = contentBlock["type"].toString();
if (blockType == "thinking") {
QString signature = contentBlock["signature"].toString();
if (!signature.isEmpty()) {
auto allBlocks = message->getCurrentBlocks();
if (index < allBlocks.size()) {
if (auto thinkingContent = qobject_cast<LLMCore::ThinkingContent *>(allBlocks[index])) {
thinkingContent->setSignature(signature);
LOG_MESSAGE(
QString("Updated thinking block signature from content_block_stop, "
"signature length=%1")
.arg(signature.length()));
}
}
}
} else if (blockType == "redacted_thinking") {
QString signature = contentBlock["signature"].toString();
if (!signature.isEmpty()) {
auto allBlocks = message->getCurrentBlocks();
if (index < allBlocks.size()) {
if (auto redactedContent = qobject_cast<LLMCore::RedactedThinkingContent *>(allBlocks[index])) {
redactedContent->setSignature(signature);
LOG_MESSAGE(
QString("Updated redacted_thinking block signature from content_block_stop, "
"signature length=%1")
.arg(signature.length()));
}
}
}
}
}
message->handleContentBlockStop(index);
auto thinkingBlocks = message->getCurrentThinkingContent();
for (auto thinkingContent : thinkingBlocks) {
auto allBlocks = message->getCurrentBlocks();
if (index < allBlocks.size() && allBlocks[index] == thinkingContent) {
emit thinkingBlockReceived(
requestId, thinkingContent->thinking(), thinkingContent->signature());
LOG_MESSAGE(
QString("Emitted thinking block for request %1, thinking length=%2, signature length=%3")
.arg(requestId)
.arg(thinkingContent->thinking().length())
.arg(thinkingContent->signature().length()));
break;
}
}
auto redactedBlocks = message->getCurrentRedactedThinkingContent();
for (auto redactedContent : redactedBlocks) {
auto allBlocks = message->getCurrentBlocks();
if (index < allBlocks.size() && allBlocks[index] == redactedContent) {
emit redactedThinkingBlockReceived(requestId, redactedContent->signature());
LOG_MESSAGE(
QString("Emitted redacted thinking block for request %1, signature length=%2")
.arg(requestId)
.arg(redactedContent->signature().length()));
break;
}
}
} else if (eventType == "message_delta") {
QJsonObject delta = event["delta"].toObject();
if (delta.contains("stop_reason")) {
QString stopReason = delta["stop_reason"].toString();
message->handleStopReason(stopReason);
handleMessageComplete(requestId);
}
}
}
void ClaudeProvider::handleMessageComplete(const QString &requestId)
{
if (!m_messages.contains(requestId))
return;
ClaudeMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Claude message requires tool execution for %1").arg(requestId));
auto toolUseContent = message->getCurrentToolUseContent();
if (toolUseContent.isEmpty()) {
LOG_MESSAGE(QString("No tools to execute for %1").arg(requestId));
return;
}
for (auto toolContent : toolUseContent) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(toolContent->name());
emit toolExecutionStarted(requestId, toolContent->id(), toolStringName);
m_toolsManager->executeToolCall(
requestId, toolContent->id(), toolContent->name(), toolContent->input());
}
} else {
LOG_MESSAGE(QString("Claude message marked as complete for %1").arg(requestId));
}
}
void ClaudeProvider::cleanupRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("Cleaning up Claude request %1").arg(requestId));
if (m_messages.contains(requestId)) {
ClaudeMessage *message = m_messages.take(requestId);
message->deleteLater();
}
m_dataBuffers.remove(requestId);
m_requestUrls.remove(requestId);
m_originalRequests.remove(requestId);
m_toolsManager->cleanupRequest(requestId);
return m_client;
}
} // namespace QodeAssist::Providers

51
providers/ClaudeProvider.hpp
View File

@@ -19,14 +19,13 @@
#pragma once
#include <llmcore/Provider.hpp>
#include <pluginllmcore/Provider.hpp>
#include "ClaudeMessage.hpp"
#include "tools/ToolsManager.hpp"
#include <LLMCore/ClaudeClient.hpp>
namespace QodeAssist::Providers {
class ClaudeProvider : public LLMCore::Provider
class ClaudeProvider : public PluginLLMCore::Provider
{
Q_OBJECT
public:
@@ -36,50 +35,22 @@ public:
QString url() const override;
QString completionEndpoint() const override;
QString chatEndpoint() const override;
bool supportsModelListing() const override;
void prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled) override;
QFuture<QList<QString>> getInstalledModels(const QString &url) override;
QList<QString> validateRequest(const QJsonObject &request, LLMCore::TemplateType type) override;
PluginLLMCore::ProviderID providerID() const override;
PluginLLMCore::ProviderCapabilities capabilities() const override;
::LLMCore::BaseClient *client() const override;
QString apiKey() const override;
void prepareNetworkRequest(QNetworkRequest &networkRequest) const override;
LLMCore::ProviderID providerID() const override;
void sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload) override;
bool supportsTools() const override;
bool supportThinking() const override;
bool supportImage() const override;
void cancelRequest(const LLMCore::RequestID &requestId) override;
LLMCore::IToolsManager *toolsManager() const override;
public slots:
void onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data) override;
void onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId,
std::optional<QString> error) override;
private slots:
void onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults);
private:
void processStreamEvent(const QString &requestId, const QJsonObject &event);
void handleMessageComplete(const QString &requestId);
void cleanupRequest(const LLMCore::RequestID &requestId);
QHash<QodeAssist::LLMCore::RequestID, ClaudeMessage *> m_messages;
QHash<QodeAssist::LLMCore::RequestID, QUrl> m_requestUrls;
QHash<QodeAssist::LLMCore::RequestID, QJsonObject> m_originalRequests;
Tools::ToolsManager *m_toolsManager;
::LLMCore::ClaudeClient *m_client;
};
} // namespace QodeAssist::Providers

24
providers/CodestralProvider.cpp
View File

@@ -23,24 +23,28 @@
namespace QodeAssist::Providers {
CodestralProvider::CodestralProvider(QObject *parent)
: MistralAIProvider(parent)
{}
QString CodestralProvider::name() const
{
return "Codestral";
}
QString CodestralProvider::url() const
{
return "https://codestral.mistral.ai";
}
bool CodestralProvider::supportsModelListing() const
{
return false;
}
QString CodestralProvider::apiKey() const
{
return Settings::providerSettings().codestralApiKey();
}
QString CodestralProvider::url() const
{
return "https://codestral.mistral.ai";
}
PluginLLMCore::ProviderCapabilities CodestralProvider::capabilities() const
{
return PluginLLMCore::ProviderCapability::Tools | PluginLLMCore::ProviderCapability::Image;
}
} // namespace QodeAssist::Providers

4
providers/CodestralProvider.hpp
View File

@@ -26,10 +26,12 @@ namespace QodeAssist::Providers {
class CodestralProvider : public MistralAIProvider
{
public:
explicit CodestralProvider(QObject *parent = nullptr);
QString name() const override;
QString url() const override;
bool supportsModelListing() const override;
QString apiKey() const override;
PluginLLMCore::ProviderCapabilities capabilities() const override;
};
} // namespace QodeAssist::Providers

460
providers/GoogleAIProvider.cpp
View File

@@ -19,12 +19,14 @@
#include "GoogleAIProvider.hpp"
#include <LLMCore/ToolsManager.hpp>
#include <QJsonArray>
#include "tools/ToolsRegistration.hpp"
#include <QJsonDocument>
#include <QJsonObject>
#include <QtCore/qurlquery.h>
#include "llmcore/ValidationUtils.hpp"
#include "logger/Logger.hpp"
#include "settings/ChatAssistantSettings.hpp"
#include "settings/CodeCompletionSettings.hpp"
@@ -35,14 +37,10 @@
namespace QodeAssist::Providers {
GoogleAIProvider::GoogleAIProvider(QObject *parent)
: LLMCore::Provider(parent)
, m_toolsManager(new Tools::ToolsManager(this))
: PluginLLMCore::Provider(parent)
, m_client(new ::LLMCore::GoogleAIClient(QString(), QString(), QString(), this))
{
connect(
m_toolsManager,
&Tools::ToolsManager::toolExecutionComplete,
this,
&GoogleAIProvider::onToolExecutionComplete);
Tools::registerQodeAssistTools(m_client->tools());
}
QString GoogleAIProvider::name() const
@@ -50,6 +48,11 @@ QString GoogleAIProvider::name() const
return "Google AI";
}
QString GoogleAIProvider::apiKey() const
{
return Settings::providerSettings().googleAiApiKey();
}
QString GoogleAIProvider::url() const
{
return "https://generativelanguage.googleapis.com/v1beta";
@@ -65,16 +68,11 @@ QString GoogleAIProvider::chatEndpoint() const
return {};
}
bool GoogleAIProvider::supportsModelListing() const
{
return true;
}
void GoogleAIProvider::prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
{
@@ -119,9 +117,9 @@ void GoogleAIProvider::prepareRequest(
request["generationConfig"] = generationConfig;
};
if (type == LLMCore::RequestType::CodeCompletion) {
if (type == PluginLLMCore::RequestType::CodeCompletion) {
applyModelParams(Settings::codeCompletionSettings());
} else if (type == LLMCore::RequestType::QuickRefactoring) {
} else if (type == PluginLLMCore::RequestType::QuickRefactoring) {
const auto &qrSettings = Settings::quickRefactorSettings();
if (isThinkingEnabled) {
@@ -140,13 +138,7 @@ void GoogleAIProvider::prepareRequest(
}
if (isToolsEnabled) {
LLMCore::RunToolsFilter filter = LLMCore::RunToolsFilter::ALL;
if (type == LLMCore::RequestType::QuickRefactoring) {
filter = LLMCore::RunToolsFilter::OnlyRead;
}
auto toolsDefinitions = m_toolsManager->getToolsDefinitions(
LLMCore::ToolSchemaFormat::Google, filter);
auto toolsDefinitions = m_client->tools()->getToolsDefinitions();
if (!toolsDefinitions.isEmpty()) {
request["tools"] = toolsDefinitions;
LOG_MESSAGE(QString("Added %1 tools to Google AI request").arg(toolsDefinitions.size()));
@@ -154,422 +146,28 @@ void GoogleAIProvider::prepareRequest(
}
}
QFuture<QList<QString>> GoogleAIProvider::getInstalledModels(const QString &url)
QFuture<QList<QString>> GoogleAIProvider::getInstalledModels(const QString &baseUrl)
{
QNetworkRequest request(QString("%1/models?key=%2").arg(url, apiKey()));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
return httpClient()->get(request).then([](const QByteArray &data) {
QList<QString> models;
QJsonObject jsonObject = QJsonDocument::fromJson(data).object();
if (jsonObject.contains("models")) {
QJsonArray modelArray = jsonObject["models"].toArray();
for (const QJsonValue &value : modelArray) {
QJsonObject modelObject = value.toObject();
if (modelObject.contains("name")) {
QString modelName = modelObject["name"].toString();
if (modelName.contains("/")) {
modelName = modelName.split("/").last();
}
models.append(modelName);
}
}
}
return models;
}).onFailed([](const std::exception &e) {
LOG_MESSAGE(QString("Error fetching Google AI models: %1").arg(e.what()));
return QList<QString>{};
});
m_client->setUrl(baseUrl);
m_client->setApiKey(apiKey());
return m_client->listModels();
}
QList<QString> GoogleAIProvider::validateRequest(
const QJsonObject &request, LLMCore::TemplateType type)
PluginLLMCore::ProviderID GoogleAIProvider::providerID() const
{
QJsonObject templateReq;
templateReq = QJsonObject{
{"contents", QJsonArray{}},
{"system_instruction", QJsonArray{}},
{"generationConfig",
QJsonObject{
{"temperature", {}},
{"maxOutputTokens", {}},
{"topP", {}},
{"topK", {}},
{"thinkingConfig",
QJsonObject{{"thinkingBudget", {}}, {"includeThoughts", {}}}}}},
{"safetySettings", QJsonArray{}},
{"tools", QJsonArray{}}};
return LLMCore::ValidationUtils::validateRequestFields(request, templateReq);
return PluginLLMCore::ProviderID::GoogleAI;
}
QString GoogleAIProvider::apiKey() const
PluginLLMCore::ProviderCapabilities GoogleAIProvider::capabilities() const
{
return Settings::providerSettings().googleAiApiKey();
return PluginLLMCore::ProviderCapability::Tools | PluginLLMCore::ProviderCapability::Thinking
| PluginLLMCore::ProviderCapability::Image
| PluginLLMCore::ProviderCapability::ModelListing;
}
void GoogleAIProvider::prepareNetworkRequest(QNetworkRequest &networkRequest) const
::LLMCore::BaseClient *GoogleAIProvider::client() const
{
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
QUrl url = networkRequest.url();
QUrlQuery query(url.query());
query.addQueryItem("key", apiKey());
url.setQuery(query);
networkRequest.setUrl(url);
}
LLMCore::ProviderID GoogleAIProvider::providerID() const
{
return LLMCore::ProviderID::GoogleAI;
}
void GoogleAIProvider::sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload)
{
if (!m_messages.contains(requestId)) {
m_dataBuffers[requestId].clear();
}
m_requestUrls[requestId] = url;
m_originalRequests[requestId] = payload;
QNetworkRequest networkRequest(url);
prepareNetworkRequest(networkRequest);
LOG_MESSAGE(
QString("GoogleAIProvider: Sending request %1 to %2").arg(requestId, url.toString()));
httpClient()->postStreaming(requestId, networkRequest, payload);
}
bool GoogleAIProvider::supportsTools() const
{
return true;
}
bool GoogleAIProvider::supportThinking() const
{
return true;
}
bool GoogleAIProvider::supportImage() const
{
return true;
}
void GoogleAIProvider::cancelRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("GoogleAIProvider: Cancelling request %1").arg(requestId));
LLMCore::Provider::cancelRequest(requestId);
cleanupRequest(requestId);
}
void GoogleAIProvider::onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data)
{
if (data.isEmpty()) {
return;
}
QJsonParseError parseError;
QJsonDocument doc = QJsonDocument::fromJson(data, &parseError);
if (!doc.isNull() && doc.isObject()) {
QJsonObject obj = doc.object();
if (obj.contains("error")) {
QJsonObject error = obj["error"].toObject();
QString errorMessage = error["message"].toString();
int errorCode = error["code"].toInt();
QString fullError
= QString("Google AI API Error %1: %2").arg(errorCode).arg(errorMessage);
LOG_MESSAGE(fullError);
emit requestFailed(requestId, fullError);
cleanupRequest(requestId);
return;
}
}
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
QStringList lines = buffers.rawStreamBuffer.processData(data);
for (const QString &line : lines) {
if (line.trimmed().isEmpty()) {
continue;
}
QJsonObject chunk = parseEventLine(line);
if (chunk.isEmpty())
continue;
processStreamChunk(requestId, chunk);
}
}
void GoogleAIProvider::onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId, std::optional<QString> error)
{
if (error) {
LOG_MESSAGE(QString("GoogleAIProvider request %1 failed: %2").arg(requestId, *error));
emit requestFailed(requestId, *error);
cleanupRequest(requestId);
return;
}
if (m_failedRequests.contains(requestId)) {
cleanupRequest(requestId);
return;
}
emitPendingThinkingBlocks(requestId);
if (m_messages.contains(requestId)) {
GoogleMessage *message = m_messages[requestId];
handleMessageComplete(requestId);
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Waiting for tools to complete for %1").arg(requestId));
m_dataBuffers.remove(requestId);
return;
}
}
if (m_dataBuffers.contains(requestId)) {
const LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
if (!buffers.responseContent.isEmpty()) {
emit fullResponseReceived(requestId, buffers.responseContent);
} else {
emit fullResponseReceived(requestId, QString());
}
} else {
emit fullResponseReceived(requestId, QString());
}
cleanupRequest(requestId);
}
void GoogleAIProvider::onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults)
{
if (!m_messages.contains(requestId) || !m_requestUrls.contains(requestId)) {
LOG_MESSAGE(QString("ERROR: Missing data for continuation request %1").arg(requestId));
cleanupRequest(requestId);
return;
}
for (auto it = toolResults.begin(); it != toolResults.end(); ++it) {
GoogleMessage *message = m_messages[requestId];
auto toolContent = message->getCurrentToolUseContent();
for (auto tool : toolContent) {
if (tool->id() == it.key()) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(tool->name());
emit toolExecutionCompleted(
requestId, tool->id(), toolStringName, toolResults[tool->id()]);
break;
}
}
}
GoogleMessage *message = m_messages[requestId];
QJsonObject continuationRequest = m_originalRequests[requestId];
QJsonArray contents = continuationRequest["contents"].toArray();
contents.append(message->toProviderFormat());
QJsonObject userMessage;
userMessage["role"] = "user";
userMessage["parts"] = message->createToolResultParts(toolResults);
contents.append(userMessage);
continuationRequest["contents"] = contents;
sendRequest(requestId, m_requestUrls[requestId], continuationRequest);
}
void GoogleAIProvider::processStreamChunk(const QString &requestId, const QJsonObject &chunk)
{
if (!chunk.contains("candidates")) {
return;
}
GoogleMessage *message = m_messages.value(requestId);
if (!message) {
message = new GoogleMessage(this);
m_messages[requestId] = message;
LOG_MESSAGE(QString("Created NEW GoogleMessage for request %1").arg(requestId));
if (m_dataBuffers.contains(requestId)) {
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Starting continuation for request %1").arg(requestId));
}
} else if (
m_dataBuffers.contains(requestId)
&& message->state() == LLMCore::MessageState::RequiresToolExecution) {
message->startNewContinuation();
m_emittedThinkingBlocksCount[requestId] = 0;
LOG_MESSAGE(QString("Cleared message state for continuation request %1").arg(requestId));
}
QJsonArray candidates = chunk["candidates"].toArray();
for (const QJsonValue &candidate : candidates) {
QJsonObject candidateObj = candidate.toObject();
if (candidateObj.contains("content")) {
QJsonObject content = candidateObj["content"].toObject();
if (content.contains("parts")) {
QJsonArray parts = content["parts"].toArray();
for (const QJsonValue &part : parts) {
QJsonObject partObj = part.toObject();
if (partObj.contains("text")) {
QString text = partObj["text"].toString();
bool isThought = partObj.value("thought").toBool(false);
if (isThought) {
message->handleThoughtDelta(text);
if (partObj.contains("signature")) {
QString signature = partObj["signature"].toString();
message->handleThoughtSignature(signature);
}
} else {
emitPendingThinkingBlocks(requestId);
message->handleContentDelta(text);
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
buffers.responseContent += text;
emit partialResponseReceived(requestId, text);
}
}
if (partObj.contains("thoughtSignature")) {
QString signature = partObj["thoughtSignature"].toString();
message->handleThoughtSignature(signature);
}
if (partObj.contains("functionCall")) {
emitPendingThinkingBlocks(requestId);
QJsonObject functionCall = partObj["functionCall"].toObject();
QString name = functionCall["name"].toString();
QJsonObject args = functionCall["args"].toObject();
message->handleFunctionCallStart(name);
message->handleFunctionCallArgsDelta(
QString::fromUtf8(QJsonDocument(args).toJson(QJsonDocument::Compact)));
message->handleFunctionCallComplete();
}
}
}
}
if (candidateObj.contains("finishReason")) {
QString finishReason = candidateObj["finishReason"].toString();
message->handleFinishReason(finishReason);
if (message->isErrorFinishReason()) {
QString errorMessage = message->getErrorMessage();
LOG_MESSAGE(QString("Google AI error: %1").arg(errorMessage));
m_failedRequests.insert(requestId);
emit requestFailed(requestId, errorMessage);
return;
}
}
}
if (chunk.contains("usageMetadata")) {
QJsonObject usageMetadata = chunk["usageMetadata"].toObject();
int thoughtsTokenCount = usageMetadata.value("thoughtsTokenCount").toInt(0);
int candidatesTokenCount = usageMetadata.value("candidatesTokenCount").toInt(0);
int totalTokenCount = usageMetadata.value("totalTokenCount").toInt(0);
if (totalTokenCount > 0) {
LOG_MESSAGE(QString("Google AI tokens: %1 (thoughts: %2, output: %3)")
.arg(totalTokenCount)
.arg(thoughtsTokenCount)
.arg(candidatesTokenCount));
}
}
}
void GoogleAIProvider::emitPendingThinkingBlocks(const QString &requestId)
{
if (!m_messages.contains(requestId))
return;
GoogleMessage *message = m_messages[requestId];
auto thinkingBlocks = message->getCurrentThinkingContent();
if (thinkingBlocks.isEmpty())
return;
int alreadyEmitted = m_emittedThinkingBlocksCount.value(requestId, 0);
int totalBlocks = thinkingBlocks.size();
for (int i = alreadyEmitted; i < totalBlocks; ++i) {
auto thinkingContent = thinkingBlocks[i];
if (thinkingContent->thinking().trimmed().isEmpty()) {
continue;
}
emit thinkingBlockReceived(
requestId,
thinkingContent->thinking(),
thinkingContent->signature());
}
m_emittedThinkingBlocksCount[requestId] = totalBlocks;
}
void GoogleAIProvider::handleMessageComplete(const QString &requestId)
{
if (!m_messages.contains(requestId))
return;
GoogleMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Google AI message requires tool execution for %1").arg(requestId));
auto toolUseContent = message->getCurrentToolUseContent();
if (toolUseContent.isEmpty()) {
LOG_MESSAGE(QString("No tools to execute for %1").arg(requestId));
return;
}
for (auto toolContent : toolUseContent) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(toolContent->name());
emit toolExecutionStarted(requestId, toolContent->id(), toolStringName);
m_toolsManager->executeToolCall(
requestId, toolContent->id(), toolContent->name(), toolContent->input());
}
} else {
LOG_MESSAGE(QString("Google AI message marked as complete for %1").arg(requestId));
}
}
void GoogleAIProvider::cleanupRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("Cleaning up Google AI request %1").arg(requestId));
if (m_messages.contains(requestId)) {
GoogleMessage *message = m_messages.take(requestId);
message->deleteLater();
}
m_dataBuffers.remove(requestId);
m_requestUrls.remove(requestId);
m_originalRequests.remove(requestId);
m_emittedThinkingBlocksCount.remove(requestId);
m_failedRequests.remove(requestId);
m_toolsManager->cleanupRequest(requestId);
return m_client;
}
} // namespace QodeAssist::Providers

53
providers/GoogleAIProvider.hpp
View File

@@ -19,13 +19,13 @@
#pragma once
#include "GoogleMessage.hpp"
#include "llmcore/Provider.hpp"
#include "tools/ToolsManager.hpp"
#include <pluginllmcore/Provider.hpp>
#include <LLMCore/GoogleAIClient.hpp>
namespace QodeAssist::Providers {
class GoogleAIProvider : public LLMCore::Provider
class GoogleAIProvider : public PluginLLMCore::Provider
{
Q_OBJECT
public:
@@ -35,51 +35,22 @@ public:
QString url() const override;
QString completionEndpoint() const override;
QString chatEndpoint() const override;
bool supportsModelListing() const override;
void prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled) override;
QFuture<QList<QString>> getInstalledModels(const QString &url) override;
QList<QString> validateRequest(const QJsonObject &request, LLMCore::TemplateType type) override;
PluginLLMCore::ProviderID providerID() const override;
PluginLLMCore::ProviderCapabilities capabilities() const override;
::LLMCore::BaseClient *client() const override;
QString apiKey() const override;
void prepareNetworkRequest(QNetworkRequest &networkRequest) const override;
LLMCore::ProviderID providerID() const override;
void sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload) override;
bool supportsTools() const override;
bool supportThinking() const override;
bool supportImage() const override;
void cancelRequest(const LLMCore::RequestID &requestId) override;
public slots:
void onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data) override;
void onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId,
std::optional<QString> error) override;
private slots:
void onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults);
private:
void processStreamChunk(const QString &requestId, const QJsonObject &chunk);
void handleMessageComplete(const QString &requestId);
void emitPendingThinkingBlocks(const QString &requestId);
void cleanupRequest(const LLMCore::RequestID &requestId);
QHash<LLMCore::RequestID, GoogleMessage *> m_messages;
QHash<LLMCore::RequestID, QUrl> m_requestUrls;
QHash<LLMCore::RequestID, QJsonObject> m_originalRequests;
QHash<LLMCore::RequestID, int> m_emittedThinkingBlocksCount;
QSet<LLMCore::RequestID> m_failedRequests;
Tools::ToolsManager *m_toolsManager;
::LLMCore::GoogleAIClient *m_client;
};
} // namespace QodeAssist::Providers

44
providers/GoogleMessage.cpp
View File

@@ -32,26 +32,26 @@ GoogleMessage::GoogleMessage(QObject *parent)
void GoogleMessage::handleContentDelta(const QString &text)
{
if (m_currentBlocks.isEmpty() || !qobject_cast<LLMCore::TextContent *>(m_currentBlocks.last())) {
auto textContent = new LLMCore::TextContent();
if (m_currentBlocks.isEmpty() || !qobject_cast<PluginLLMCore::TextContent *>(m_currentBlocks.last())) {
auto textContent = new PluginLLMCore::TextContent();
textContent->setParent(this);
m_currentBlocks.append(textContent);
}
if (auto textContent = qobject_cast<LLMCore::TextContent *>(m_currentBlocks.last())) {
if (auto textContent = qobject_cast<PluginLLMCore::TextContent *>(m_currentBlocks.last())) {
textContent->appendText(text);
}
}
void GoogleMessage::handleThoughtDelta(const QString &text)
{
if (m_currentBlocks.isEmpty() || !qobject_cast<LLMCore::ThinkingContent *>(m_currentBlocks.last())) {
auto thinkingContent = new LLMCore::ThinkingContent();
if (m_currentBlocks.isEmpty() || !qobject_cast<PluginLLMCore::ThinkingContent *>(m_currentBlocks.last())) {
auto thinkingContent = new PluginLLMCore::ThinkingContent();
thinkingContent->setParent(this);
m_currentBlocks.append(thinkingContent);
}
if (auto thinkingContent = qobject_cast<LLMCore::ThinkingContent *>(m_currentBlocks.last())) {
if (auto thinkingContent = qobject_cast<PluginLLMCore::ThinkingContent *>(m_currentBlocks.last())) {
thinkingContent->appendThinking(text);
}
}
@@ -59,13 +59,13 @@ void GoogleMessage::handleThoughtDelta(const QString &text)
void GoogleMessage::handleThoughtSignature(const QString &signature)
{
for (int i = m_currentBlocks.size() - 1; i >= 0; --i) {
if (auto thinkingContent = qobject_cast<LLMCore::ThinkingContent *>(m_currentBlocks[i])) {
if (auto thinkingContent = qobject_cast<PluginLLMCore::ThinkingContent *>(m_currentBlocks[i])) {
thinkingContent->setSignature(signature);
return;
}
}
auto thinkingContent = new LLMCore::ThinkingContent();
auto thinkingContent = new PluginLLMCore::ThinkingContent();
thinkingContent->setParent(this);
thinkingContent->setSignature(signature);
m_currentBlocks.append(thinkingContent);
@@ -97,7 +97,7 @@ void GoogleMessage::handleFunctionCallComplete()
}
QString id = QUuid::createUuid().toString(QUuid::WithoutBraces);
auto toolContent = new LLMCore::ToolUseContent(id, m_currentFunctionName, args);
auto toolContent = new PluginLLMCore::ToolUseContent(id, m_currentFunctionName, args);
toolContent->setParent(this);
m_currentBlocks.append(toolContent);
@@ -122,14 +122,14 @@ QJsonObject GoogleMessage::toProviderFormat() const
if (!block)
continue;
if (auto text = qobject_cast<LLMCore::TextContent *>(block)) {
if (auto text = qobject_cast<PluginLLMCore::TextContent *>(block)) {
parts.append(QJsonObject{{"text", text->text()}});
} else if (auto tool = qobject_cast<LLMCore::ToolUseContent *>(block)) {
} else if (auto tool = qobject_cast<PluginLLMCore::ToolUseContent *>(block)) {
QJsonObject functionCall;
functionCall["name"] = tool->name();
functionCall["args"] = tool->input();
parts.append(QJsonObject{{"functionCall", functionCall}});
} else if (auto thinking = qobject_cast<LLMCore::ThinkingContent *>(block)) {
} else if (auto thinking = qobject_cast<PluginLLMCore::ThinkingContent *>(block)) {
// Include thinking blocks with their text
QJsonObject thinkingPart;
thinkingPart["text"] = thinking->thinking();
@@ -169,22 +169,22 @@ QJsonArray GoogleMessage::createToolResultParts(const QHash<QString, QString> &t
return parts;
}
QList<LLMCore::ToolUseContent *> GoogleMessage::getCurrentToolUseContent() const
QList<PluginLLMCore::ToolUseContent *> GoogleMessage::getCurrentToolUseContent() const
{
QList<LLMCore::ToolUseContent *> toolBlocks;
QList<PluginLLMCore::ToolUseContent *> toolBlocks;
for (auto block : m_currentBlocks) {
if (auto toolContent = qobject_cast<LLMCore::ToolUseContent *>(block)) {
if (auto toolContent = qobject_cast<PluginLLMCore::ToolUseContent *>(block)) {
toolBlocks.append(toolContent);
}
}
return toolBlocks;
}
QList<LLMCore::ThinkingContent *> GoogleMessage::getCurrentThinkingContent() const
QList<PluginLLMCore::ThinkingContent *> GoogleMessage::getCurrentThinkingContent() const
{
QList<LLMCore::ThinkingContent *> thinkingBlocks;
QList<PluginLLMCore::ThinkingContent *> thinkingBlocks;
for (auto block : m_currentBlocks) {
if (auto thinkingContent = qobject_cast<LLMCore::ThinkingContent *>(block)) {
if (auto thinkingContent = qobject_cast<PluginLLMCore::ThinkingContent *>(block)) {
thinkingBlocks.append(thinkingContent);
}
}
@@ -199,7 +199,7 @@ void GoogleMessage::startNewContinuation()
m_pendingFunctionArgs.clear();
m_currentFunctionName.clear();
m_finishReason.clear();
m_state = LLMCore::MessageState::Building;
m_state = PluginLLMCore::MessageState::Building;
}
bool GoogleMessage::isErrorFinishReason() const
@@ -234,10 +234,10 @@ void GoogleMessage::updateStateFromFinishReason()
{
if (m_finishReason == "STOP" || m_finishReason == "MAX_TOKENS") {
m_state = getCurrentToolUseContent().isEmpty()
? LLMCore::MessageState::Complete
: LLMCore::MessageState::RequiresToolExecution;
? PluginLLMCore::MessageState::Complete
: PluginLLMCore::MessageState::RequiresToolExecution;
} else {
m_state = LLMCore::MessageState::Complete;
m_state = PluginLLMCore::MessageState::Complete;
}
}

14
providers/GoogleMessage.hpp
View File

@@ -24,7 +24,7 @@
#include <QJsonObject>
#include <QObject>
#include <llmcore/ContentBlocks.hpp>
#include <pluginllmcore/ContentBlocks.hpp>
namespace QodeAssist::Providers {
@@ -45,11 +45,11 @@ public:
QJsonObject toProviderFormat() const;
QJsonArray createToolResultParts(const QHash<QString, QString> &toolResults) const;
QList<LLMCore::ToolUseContent *> getCurrentToolUseContent() const;
QList<LLMCore::ThinkingContent *> getCurrentThinkingContent() const;
QList<LLMCore::ContentBlock *> currentBlocks() const { return m_currentBlocks; }
QList<PluginLLMCore::ToolUseContent *> getCurrentToolUseContent() const;
QList<PluginLLMCore::ThinkingContent *> getCurrentThinkingContent() const;
QList<PluginLLMCore::ContentBlock *> currentBlocks() const { return m_currentBlocks; }
LLMCore::MessageState state() const { return m_state; }
PluginLLMCore::MessageState state() const { return m_state; }
QString finishReason() const { return m_finishReason; }
bool isErrorFinishReason() const;
QString getErrorMessage() const;
@@ -58,11 +58,11 @@ public:
private:
void updateStateFromFinishReason();
QList<LLMCore::ContentBlock *> m_currentBlocks;
QList<PluginLLMCore::ContentBlock *> m_currentBlocks;
QString m_pendingFunctionArgs;
QString m_currentFunctionName;
QString m_finishReason;
LLMCore::MessageState m_state = LLMCore::MessageState::Building;
PluginLLMCore::MessageState m_state = PluginLLMCore::MessageState::Building;
};
} // namespace QodeAssist::Providers

337
providers/LMStudioProvider.cpp
View File

@@ -19,7 +19,9 @@
#include "LMStudioProvider.hpp"
#include "llmcore/ValidationUtils.hpp"
#include <LLMCore/ToolsManager.hpp>
#include "tools/ToolsRegistration.hpp"
#include "logger/Logger.hpp"
#include "settings/ChatAssistantSettings.hpp"
#include "settings/CodeCompletionSettings.hpp"
@@ -34,14 +36,10 @@
namespace QodeAssist::Providers {
LMStudioProvider::LMStudioProvider(QObject *parent)
: LLMCore::Provider(parent)
, m_toolsManager(new Tools::ToolsManager(this))
: PluginLLMCore::Provider(parent)
, m_client(new ::LLMCore::OpenAIClient(QString(), QString(), QString(), this))
{
connect(
m_toolsManager,
&Tools::ToolsManager::toolExecutionComplete,
this,
&LMStudioProvider::onToolExecutionComplete);
Tools::registerQodeAssistTools(m_client->tools());
}
QString LMStudioProvider::name() const
@@ -49,6 +47,11 @@ QString LMStudioProvider::name() const
return "LM Studio";
}
QString LMStudioProvider::apiKey() const
{
return {};
}
QString LMStudioProvider::url() const
{
return "http://localhost:1234";
@@ -64,155 +67,29 @@ QString LMStudioProvider::chatEndpoint() const
return "/v1/chat/completions";
}
bool LMStudioProvider::supportsModelListing() const
{
return true;
}
QFuture<QList<QString>> LMStudioProvider::getInstalledModels(const QString &url)
{
QNetworkRequest request(QString("%1%2").arg(url, "/v1/models"));
return httpClient()->get(request).then([](const QByteArray &data) {
QList<QString> models;
QJsonObject jsonObject = QJsonDocument::fromJson(data).object();
QJsonArray modelArray = jsonObject["data"].toArray();
for (const QJsonValue &value : modelArray) {
QJsonObject modelObject = value.toObject();
models.append(modelObject["id"].toString());
}
return models;
}).onFailed([](const std::exception &e) {
LOG_MESSAGE(QString("Error fetching LMStudio models: %1").arg(e.what()));
return QList<QString>{};
});
m_client->setUrl(url);
m_client->setApiKey(apiKey());
return m_client->listModels();
}
QList<QString> LMStudioProvider::validateRequest(
const QJsonObject &request, LLMCore::TemplateType type)
PluginLLMCore::ProviderID LMStudioProvider::providerID() const
{
const auto templateReq = QJsonObject{
{"model", {}},
{"messages", QJsonArray{{QJsonObject{{"role", {}}, {"content", {}}}}}},
{"temperature", {}},
{"max_tokens", {}},
{"top_p", {}},
{"top_k", {}},
{"frequency_penalty", {}},
{"presence_penalty", {}},
{"stop", QJsonArray{}},
{"stream", {}},
{"tools", {}}};
return LLMCore::ValidationUtils::validateRequestFields(request, templateReq);
return PluginLLMCore::ProviderID::LMStudio;
}
QString LMStudioProvider::apiKey() const
PluginLLMCore::ProviderCapabilities LMStudioProvider::capabilities() const
{
return {};
}
void LMStudioProvider::prepareNetworkRequest(QNetworkRequest &networkRequest) const
{
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
}
LLMCore::ProviderID LMStudioProvider::providerID() const
{
return LLMCore::ProviderID::LMStudio;
}
void LMStudioProvider::sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload)
{
if (!m_messages.contains(requestId)) {
m_dataBuffers[requestId].clear();
}
m_requestUrls[requestId] = url;
m_originalRequests[requestId] = payload;
QNetworkRequest networkRequest(url);
prepareNetworkRequest(networkRequest);
LOG_MESSAGE(
QString("LMStudioProvider: Sending request %1 to %2").arg(requestId, url.toString()));
httpClient()->postStreaming(requestId, networkRequest, payload);
}
bool LMStudioProvider::supportsTools() const
{
return true;
}
bool LMStudioProvider::supportImage() const
{
return true;
}
void LMStudioProvider::cancelRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("LMStudioProvider: Cancelling request %1").arg(requestId));
LLMCore::Provider::cancelRequest(requestId);
cleanupRequest(requestId);
}
void LMStudioProvider::onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data)
{
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
QStringList lines = buffers.rawStreamBuffer.processData(data);
for (const QString &line : lines) {
if (line.trimmed().isEmpty() || line == "data: [DONE]") {
continue;
}
QJsonObject chunk = parseEventLine(line);
if (chunk.isEmpty())
continue;
processStreamChunk(requestId, chunk);
}
}
void LMStudioProvider::onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId, std::optional<QString> error)
{
if (error) {
LOG_MESSAGE(QString("LMStudioProvider request %1 failed: %2").arg(requestId, *error));
emit requestFailed(requestId, *error);
cleanupRequest(requestId);
return;
}
if (m_messages.contains(requestId)) {
OpenAIMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Waiting for tools to complete for %1").arg(requestId));
m_dataBuffers.remove(requestId);
return;
}
}
if (m_dataBuffers.contains(requestId)) {
const LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
if (!buffers.responseContent.isEmpty()) {
LOG_MESSAGE(QString("Emitting full response for %1").arg(requestId));
emit fullResponseReceived(requestId, buffers.responseContent);
}
}
cleanupRequest(requestId);
return PluginLLMCore::ProviderCapability::Tools | PluginLLMCore::ProviderCapability::Image
| PluginLLMCore::ProviderCapability::ModelListing;
}
void LMStudioProvider::prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
{
@@ -236,22 +113,16 @@ void LMStudioProvider::prepareRequest(
request["presence_penalty"] = settings.presencePenalty();
};
if (type == LLMCore::RequestType::CodeCompletion) {
if (type == PluginLLMCore::RequestType::CodeCompletion) {
applyModelParams(Settings::codeCompletionSettings());
} else if (type == LLMCore::RequestType::QuickRefactoring) {
} else if (type == PluginLLMCore::RequestType::QuickRefactoring) {
applyModelParams(Settings::quickRefactorSettings());
} else {
applyModelParams(Settings::chatAssistantSettings());
}
if (isToolsEnabled) {
LLMCore::RunToolsFilter filter = LLMCore::RunToolsFilter::ALL;
if (type == LLMCore::RequestType::QuickRefactoring) {
filter = LLMCore::RunToolsFilter::OnlyRead;
}
auto toolsDefinitions = m_toolsManager->getToolsDefinitions(
LLMCore::ToolSchemaFormat::OpenAI, filter);
auto toolsDefinitions = m_client->tools()->getToolsDefinitions();
if (!toolsDefinitions.isEmpty()) {
request["tools"] = toolsDefinitions;
LOG_MESSAGE(QString("Added %1 tools to LMStudio request").arg(toolsDefinitions.size()));
@@ -259,163 +130,9 @@ void LMStudioProvider::prepareRequest(
}
}
void LMStudioProvider::onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults)
::LLMCore::BaseClient *LMStudioProvider::client() const
{
if (!m_messages.contains(requestId) || !m_requestUrls.contains(requestId)) {
LOG_MESSAGE(QString("ERROR: Missing data for continuation request %1").arg(requestId));
cleanupRequest(requestId);
return;
}
LOG_MESSAGE(QString("Tool execution complete for LMStudio request %1").arg(requestId));
for (auto it = toolResults.begin(); it != toolResults.end(); ++it) {
OpenAIMessage *message = m_messages[requestId];
auto toolContent = message->getCurrentToolUseContent();
for (auto tool : toolContent) {
if (tool->id() == it.key()) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(tool->name());
emit toolExecutionCompleted(
requestId, tool->id(), toolStringName, toolResults[tool->id()]);
break;
}
}
}
OpenAIMessage *message = m_messages[requestId];
QJsonObject continuationRequest = m_originalRequests[requestId];
QJsonArray messages = continuationRequest["messages"].toArray();
messages.append(message->toProviderFormat());
QJsonArray toolResultMessages = message->createToolResultMessages(toolResults);
for (const auto &toolMsg : toolResultMessages) {
messages.append(toolMsg);
}
continuationRequest["messages"] = messages;
LOG_MESSAGE(QString("Sending continuation request for %1 with %2 tool results")
.arg(requestId)
.arg(toolResults.size()));
sendRequest(requestId, m_requestUrls[requestId], continuationRequest);
}
void LMStudioProvider::processStreamChunk(const QString &requestId, const QJsonObject &chunk)
{
QJsonArray choices = chunk["choices"].toArray();
if (choices.isEmpty()) {
return;
}
QJsonObject choice = choices[0].toObject();
QJsonObject delta = choice["delta"].toObject();
QString finishReason = choice["finish_reason"].toString();
OpenAIMessage *message = m_messages.value(requestId);
if (!message) {
message = new OpenAIMessage(this);
m_messages[requestId] = message;
LOG_MESSAGE(QString("Created NEW OpenAIMessage for request %1").arg(requestId));
if (m_dataBuffers.contains(requestId)) {
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Starting continuation for request %1").arg(requestId));
}
} else if (
m_dataBuffers.contains(requestId)
&& message->state() == LLMCore::MessageState::RequiresToolExecution) {
message->startNewContinuation();
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Cleared message state for continuation request %1").arg(requestId));
}
if (delta.contains("content") && !delta["content"].isNull()) {
QString content = delta["content"].toString();
message->handleContentDelta(content);
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
buffers.responseContent += content;
emit partialResponseReceived(requestId, content);
}
if (delta.contains("tool_calls")) {
QJsonArray toolCalls = delta["tool_calls"].toArray();
for (const auto &toolCallValue : toolCalls) {
QJsonObject toolCall = toolCallValue.toObject();
int index = toolCall["index"].toInt();
if (toolCall.contains("id")) {
QString id = toolCall["id"].toString();
QJsonObject function = toolCall["function"].toObject();
QString name = function["name"].toString();
message->handleToolCallStart(index, id, name);
}
if (toolCall.contains("function")) {
QJsonObject function = toolCall["function"].toObject();
if (function.contains("arguments")) {
QString args = function["arguments"].toString();
message->handleToolCallDelta(index, args);
}
}
}
}
if (!finishReason.isEmpty() && finishReason != "null") {
for (int i = 0; i < 10; ++i) {
message->handleToolCallComplete(i);
}
message->handleFinishReason(finishReason);
handleMessageComplete(requestId);
}
}
void LMStudioProvider::handleMessageComplete(const QString &requestId)
{
if (!m_messages.contains(requestId))
return;
OpenAIMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("LMStudio message requires tool execution for %1").arg(requestId));
auto toolUseContent = message->getCurrentToolUseContent();
if (toolUseContent.isEmpty()) {
LOG_MESSAGE(QString("No tools to execute for %1").arg(requestId));
return;
}
for (auto toolContent : toolUseContent) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(toolContent->name());
emit toolExecutionStarted(requestId, toolContent->id(), toolStringName);
m_toolsManager->executeToolCall(
requestId, toolContent->id(), toolContent->name(), toolContent->input());
}
} else {
LOG_MESSAGE(QString("LMStudio message marked as complete for %1").arg(requestId));
}
}
void LMStudioProvider::cleanupRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("Cleaning up LMStudio request %1").arg(requestId));
if (m_messages.contains(requestId)) {
OpenAIMessage *message = m_messages.take(requestId);
message->deleteLater();
}
m_dataBuffers.remove(requestId);
m_requestUrls.remove(requestId);
m_originalRequests.remove(requestId);
m_toolsManager->cleanupRequest(requestId);
return m_client;
}
} // namespace QodeAssist::Providers

48
providers/LMStudioProvider.hpp
View File

@@ -19,13 +19,12 @@
#pragma once
#include "OpenAIMessage.hpp"
#include "tools/ToolsManager.hpp"
#include <llmcore/Provider.hpp>
#include <LLMCore/OpenAIClient.hpp>
#include <pluginllmcore/Provider.hpp>
namespace QodeAssist::Providers {
class LMStudioProvider : public LLMCore::Provider
class LMStudioProvider : public PluginLLMCore::Provider
{
Q_OBJECT
public:
@@ -35,47 +34,22 @@ public:
QString url() const override;
QString completionEndpoint() const override;
QString chatEndpoint() const override;
bool supportsModelListing() const override;
void prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled) override;
QFuture<QList<QString>> getInstalledModels(const QString &url) override;
QList<QString> validateRequest(const QJsonObject &request, LLMCore::TemplateType type) override;
PluginLLMCore::ProviderID providerID() const override;
PluginLLMCore::ProviderCapabilities capabilities() const override;
::LLMCore::BaseClient *client() const override;
QString apiKey() const override;
void prepareNetworkRequest(QNetworkRequest &networkRequest) const override;
LLMCore::ProviderID providerID() const override;
void sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload) override;
bool supportsTools() const override;
bool supportImage() const override;
void cancelRequest(const LLMCore::RequestID &requestId) override;
public slots:
void onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data) override;
void onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId,
std::optional<QString> error) override;
private slots:
void onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults);
private:
void processStreamChunk(const QString &requestId, const QJsonObject &chunk);
void handleMessageComplete(const QString &requestId);
void cleanupRequest(const LLMCore::RequestID &requestId);
QHash<LLMCore::RequestID, OpenAIMessage *> m_messages;
QHash<LLMCore::RequestID, QUrl> m_requestUrls;
QHash<LLMCore::RequestID, QJsonObject> m_originalRequests;
Tools::ToolsManager *m_toolsManager;
::LLMCore::OpenAIClient *m_client;
};
} // namespace QodeAssist::Providers

347
providers/LlamaCppProvider.cpp
View File

@@ -19,12 +19,13 @@
#include "LlamaCppProvider.hpp"
#include "llmcore/ValidationUtils.hpp"
#include <LLMCore/ToolsManager.hpp>
#include "logger/Logger.hpp"
#include "settings/ChatAssistantSettings.hpp"
#include "settings/CodeCompletionSettings.hpp"
#include "settings/QuickRefactorSettings.hpp"
#include "settings/GeneralSettings.hpp"
#include "tools/ToolsRegistration.hpp"
#include <QJsonArray>
#include <QJsonDocument>
@@ -33,14 +34,10 @@
namespace QodeAssist::Providers {
LlamaCppProvider::LlamaCppProvider(QObject *parent)
: LLMCore::Provider(parent)
, m_toolsManager(new Tools::ToolsManager(this))
: PluginLLMCore::Provider(parent)
, m_client(new ::LLMCore::LlamaCppClient(QString(), QString(), QString(), this))
{
connect(
m_toolsManager,
&Tools::ToolsManager::toolExecutionComplete,
this,
&LlamaCppProvider::onToolExecutionComplete);
Tools::registerQodeAssistTools(m_client->tools());
}
QString LlamaCppProvider::name() const
@@ -48,6 +45,11 @@ QString LlamaCppProvider::name() const
return "llama.cpp";
}
QString LlamaCppProvider::apiKey() const
{
return {};
}
QString LlamaCppProvider::url() const
{
return "http://localhost:8080";
@@ -63,16 +65,11 @@ QString LlamaCppProvider::chatEndpoint() const
return "/v1/chat/completions";
}
bool LlamaCppProvider::supportsModelListing() const
{
return false;
}
void LlamaCppProvider::prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
{
@@ -96,22 +93,16 @@ void LlamaCppProvider::prepareRequest(
request["presence_penalty"] = settings.presencePenalty();
};
if (type == LLMCore::RequestType::CodeCompletion) {
if (type == PluginLLMCore::RequestType::CodeCompletion) {
applyModelParams(Settings::codeCompletionSettings());
} else if (type == LLMCore::RequestType::QuickRefactoring) {
} else if (type == PluginLLMCore::RequestType::QuickRefactoring) {
applyModelParams(Settings::quickRefactorSettings());
} else {
applyModelParams(Settings::chatAssistantSettings());
}
if (isToolsEnabled) {
LLMCore::RunToolsFilter filter = LLMCore::RunToolsFilter::ALL;
if (type == LLMCore::RequestType::QuickRefactoring) {
filter = LLMCore::RunToolsFilter::OnlyRead;
}
auto toolsDefinitions = m_toolsManager->getToolsDefinitions(
LLMCore::ToolSchemaFormat::OpenAI, filter);
auto toolsDefinitions = m_client->tools()->getToolsDefinitions();
if (!toolsDefinitions.isEmpty()) {
request["tools"] = toolsDefinitions;
LOG_MESSAGE(QString("Added %1 tools to llama.cpp request").arg(toolsDefinitions.size()));
@@ -124,313 +115,19 @@ QFuture<QList<QString>> LlamaCppProvider::getInstalledModels(const QString &)
return QtFuture::makeReadyFuture(QList<QString>{});
}
QList<QString> LlamaCppProvider::validateRequest(
const QJsonObject &request, LLMCore::TemplateType type)
PluginLLMCore::ProviderID LlamaCppProvider::providerID() const
{
if (type == LLMCore::TemplateType::FIM) {
const auto infillReq = QJsonObject{
{"model", {}},
{"input_prefix", {}},
{"input_suffix", {}},
{"input_extra", {}},
{"prompt", {}},
{"temperature", {}},
{"top_p", {}},
{"top_k", {}},
{"max_tokens", {}},
{"frequency_penalty", {}},
{"presence_penalty", {}},
{"stop", QJsonArray{}},
{"stream", {}}};
return LLMCore::ValidationUtils::validateRequestFields(request, infillReq);
} else {
const auto chatReq = QJsonObject{
{"model", {}},
{"messages", QJsonArray{{QJsonObject{{"role", {}}, {"content", {}}}}}},
{"temperature", {}},
{"max_tokens", {}},
{"top_p", {}},
{"top_k", {}},
{"frequency_penalty", {}},
{"presence_penalty", {}},
{"stop", QJsonArray{}},
{"stream", {}},
{"tools", {}}};
return LLMCore::ValidationUtils::validateRequestFields(request, chatReq);
}
return PluginLLMCore::ProviderID::LlamaCpp;
}
QString LlamaCppProvider::apiKey() const
PluginLLMCore::ProviderCapabilities LlamaCppProvider::capabilities() const
{
return {};
return PluginLLMCore::ProviderCapability::Tools | PluginLLMCore::ProviderCapability::Image;
}
void LlamaCppProvider::prepareNetworkRequest(QNetworkRequest &networkRequest) const
::LLMCore::BaseClient *LlamaCppProvider::client() const
{
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
}
LLMCore::ProviderID LlamaCppProvider::providerID() const
{
return LLMCore::ProviderID::LlamaCpp;
}
void LlamaCppProvider::sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload)
{
if (!m_messages.contains(requestId)) {
m_dataBuffers[requestId].clear();
}
m_requestUrls[requestId] = url;
m_originalRequests[requestId] = payload;
QNetworkRequest networkRequest(url);
prepareNetworkRequest(networkRequest);
LOG_MESSAGE(
QString("LlamaCppProvider: Sending request %1 to %2").arg(requestId, url.toString()));
httpClient()->postStreaming(requestId, networkRequest, payload);
}
bool LlamaCppProvider::supportsTools() const
{
return true;
}
bool LlamaCppProvider::supportImage() const
{
return true;
}
void LlamaCppProvider::cancelRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("LlamaCppProvider: Cancelling request %1").arg(requestId));
LLMCore::Provider::cancelRequest(requestId);
cleanupRequest(requestId);
}
void LlamaCppProvider::onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data)
{
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
QStringList lines = buffers.rawStreamBuffer.processData(data);
for (const QString &line : lines) {
if (line.trimmed().isEmpty() || line == "data: [DONE]") {
continue;
}
QJsonObject chunk = parseEventLine(line);
if (chunk.isEmpty())
continue;
if (chunk.contains("content")) {
QString content = chunk["content"].toString();
if (!content.isEmpty()) {
buffers.responseContent += content;
emit partialResponseReceived(requestId, content);
}
if (chunk["stop"].toBool()) {
emit fullResponseReceived(requestId, buffers.responseContent);
m_dataBuffers.remove(requestId);
}
} else if (chunk.contains("choices")) {
processStreamChunk(requestId, chunk);
}
}
}
void LlamaCppProvider::onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId, std::optional<QString> error)
{
if (error) {
LOG_MESSAGE(QString("LlamaCppProvider request %1 failed: %2").arg(requestId, *error));
emit requestFailed(requestId, *error);
cleanupRequest(requestId);
return;
}
if (m_messages.contains(requestId)) {
OpenAIMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Waiting for tools to complete for %1").arg(requestId));
m_dataBuffers.remove(requestId);
return;
}
}
if (m_dataBuffers.contains(requestId)) {
const LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
if (!buffers.responseContent.isEmpty()) {
LOG_MESSAGE(QString("Emitting full response for %1").arg(requestId));
emit fullResponseReceived(requestId, buffers.responseContent);
}
}
cleanupRequest(requestId);
}
void LlamaCppProvider::onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults)
{
if (!m_messages.contains(requestId) || !m_requestUrls.contains(requestId)) {
LOG_MESSAGE(QString("ERROR: Missing data for continuation request %1").arg(requestId));
cleanupRequest(requestId);
return;
}
LOG_MESSAGE(QString("Tool execution complete for llama.cpp request %1").arg(requestId));
for (auto it = toolResults.begin(); it != toolResults.end(); ++it) {
OpenAIMessage *message = m_messages[requestId];
auto toolContent = message->getCurrentToolUseContent();
for (auto tool : toolContent) {
if (tool->id() == it.key()) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(tool->name());
emit toolExecutionCompleted(
requestId, tool->id(), toolStringName, toolResults[tool->id()]);
break;
}
}
}
OpenAIMessage *message = m_messages[requestId];
QJsonObject continuationRequest = m_originalRequests[requestId];
QJsonArray messages = continuationRequest["messages"].toArray();
messages.append(message->toProviderFormat());
QJsonArray toolResultMessages = message->createToolResultMessages(toolResults);
for (const auto &toolMsg : toolResultMessages) {
messages.append(toolMsg);
}
continuationRequest["messages"] = messages;
LOG_MESSAGE(QString("Sending continuation request for %1 with %2 tool results")
.arg(requestId)
.arg(toolResults.size()));
sendRequest(requestId, m_requestUrls[requestId], continuationRequest);
}
void LlamaCppProvider::processStreamChunk(const QString &requestId, const QJsonObject &chunk)
{
QJsonArray choices = chunk["choices"].toArray();
if (choices.isEmpty()) {
return;
}
QJsonObject choice = choices[0].toObject();
QJsonObject delta = choice["delta"].toObject();
QString finishReason = choice["finish_reason"].toString();
OpenAIMessage *message = m_messages.value(requestId);
if (!message) {
message = new OpenAIMessage(this);
m_messages[requestId] = message;
LOG_MESSAGE(QString("Created NEW OpenAIMessage for llama.cpp request %1").arg(requestId));
if (m_dataBuffers.contains(requestId)) {
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Starting continuation for request %1").arg(requestId));
}
} else if (
m_dataBuffers.contains(requestId)
&& message->state() == LLMCore::MessageState::RequiresToolExecution) {
message->startNewContinuation();
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Cleared message state for continuation request %1").arg(requestId));
}
if (delta.contains("content") && !delta["content"].isNull()) {
QString content = delta["content"].toString();
message->handleContentDelta(content);
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
buffers.responseContent += content;
emit partialResponseReceived(requestId, content);
}
if (delta.contains("tool_calls")) {
QJsonArray toolCalls = delta["tool_calls"].toArray();
for (const auto &toolCallValue : toolCalls) {
QJsonObject toolCall = toolCallValue.toObject();
int index = toolCall["index"].toInt();
if (toolCall.contains("id")) {
QString id = toolCall["id"].toString();
QJsonObject function = toolCall["function"].toObject();
QString name = function["name"].toString();
message->handleToolCallStart(index, id, name);
}
if (toolCall.contains("function")) {
QJsonObject function = toolCall["function"].toObject();
if (function.contains("arguments")) {
QString args = function["arguments"].toString();
message->handleToolCallDelta(index, args);
}
}
}
}
if (!finishReason.isEmpty() && finishReason != "null") {
for (int i = 0; i < 10; ++i) {
message->handleToolCallComplete(i);
}
message->handleFinishReason(finishReason);
handleMessageComplete(requestId);
}
}
void LlamaCppProvider::handleMessageComplete(const QString &requestId)
{
if (!m_messages.contains(requestId))
return;
OpenAIMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("llama.cpp message requires tool execution for %1").arg(requestId));
auto toolUseContent = message->getCurrentToolUseContent();
if (toolUseContent.isEmpty()) {
LOG_MESSAGE(QString("No tools to execute for %1").arg(requestId));
return;
}
for (auto toolContent : toolUseContent) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(toolContent->name());
emit toolExecutionStarted(requestId, toolContent->id(), toolStringName);
m_toolsManager->executeToolCall(
requestId, toolContent->id(), toolContent->name(), toolContent->input());
}
} else {
LOG_MESSAGE(QString("llama.cpp message marked as complete for %1").arg(requestId));
}
}
void LlamaCppProvider::cleanupRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("Cleaning up llama.cpp request %1").arg(requestId));
if (m_messages.contains(requestId)) {
OpenAIMessage *message = m_messages.take(requestId);
message->deleteLater();
}
m_dataBuffers.remove(requestId);
m_requestUrls.remove(requestId);
m_originalRequests.remove(requestId);
m_toolsManager->cleanupRequest(requestId);
return m_client;
}
} // namespace QodeAssist::Providers

49
providers/LlamaCppProvider.hpp
View File

@@ -19,13 +19,13 @@
#pragma once
#include "OpenAIMessage.hpp"
#include "tools/ToolsManager.hpp"
#include <llmcore/Provider.hpp>
#include <pluginllmcore/Provider.hpp>
#include <LLMCore/LlamaCppClient.hpp>
namespace QodeAssist::Providers {
class LlamaCppProvider : public LLMCore::Provider
class LlamaCppProvider : public PluginLLMCore::Provider
{
Q_OBJECT
public:
@@ -35,47 +35,22 @@ public:
QString url() const override;
QString completionEndpoint() const override;
QString chatEndpoint() const override;
bool supportsModelListing() const override;
void prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled) override;
QFuture<QList<QString>> getInstalledModels(const QString &url) override;
QList<QString> validateRequest(const QJsonObject &request, LLMCore::TemplateType type) override;
PluginLLMCore::ProviderID providerID() const override;
PluginLLMCore::ProviderCapabilities capabilities() const override;
::LLMCore::BaseClient *client() const override;
QString apiKey() const override;
void prepareNetworkRequest(QNetworkRequest &networkRequest) const override;
LLMCore::ProviderID providerID() const override;
void sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload) override;
bool supportsTools() const override;
bool supportImage() const override;
void cancelRequest(const LLMCore::RequestID &requestId) override;
public slots:
void onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data) override;
void onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId,
std::optional<QString> error) override;
private slots:
void onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults);
private:
void processStreamChunk(const QString &requestId, const QJsonObject &chunk);
void handleMessageComplete(const QString &requestId);
void cleanupRequest(const LLMCore::RequestID &requestId);
QHash<LLMCore::RequestID, OpenAIMessage *> m_messages;
QHash<LLMCore::RequestID, QUrl> m_requestUrls;
QHash<LLMCore::RequestID, QJsonObject> m_originalRequests;
Tools::ToolsManager *m_toolsManager;
::LLMCore::LlamaCppClient *m_client;
};
} // namespace QodeAssist::Providers

357
providers/MistralAIProvider.cpp
View File

@@ -19,13 +19,14 @@
#include "MistralAIProvider.hpp"
#include "llmcore/ValidationUtils.hpp"
#include <LLMCore/ToolsManager.hpp>
#include "logger/Logger.hpp"
#include "settings/ChatAssistantSettings.hpp"
#include "settings/CodeCompletionSettings.hpp"
#include "settings/QuickRefactorSettings.hpp"
#include "settings/GeneralSettings.hpp"
#include "settings/ProviderSettings.hpp"
#include "tools/ToolsRegistration.hpp"
#include <QJsonArray>
#include <QJsonDocument>
@@ -34,14 +35,10 @@
namespace QodeAssist::Providers {
MistralAIProvider::MistralAIProvider(QObject *parent)
: LLMCore::Provider(parent)
, m_toolsManager(new Tools::ToolsManager(this))
: PluginLLMCore::Provider(parent)
, m_client(new ::LLMCore::OpenAIClient(QString(), QString(), QString(), this))
{
connect(
m_toolsManager,
&Tools::ToolsManager::toolExecutionComplete,
this,
&MistralAIProvider::onToolExecutionComplete);
Tools::registerQodeAssistTools(m_client->tools());
}
QString MistralAIProvider::name() const
@@ -49,6 +46,11 @@ QString MistralAIProvider::name() const
return "Mistral AI";
}
QString MistralAIProvider::apiKey() const
{
return Settings::providerSettings().mistralAiApiKey();
}
QString MistralAIProvider::url() const
{
return "https://api.mistral.ai";
@@ -64,176 +66,29 @@ QString MistralAIProvider::chatEndpoint() const
return "/v1/chat/completions";
}
bool MistralAIProvider::supportsModelListing() const
{
return true;
}
QFuture<QList<QString>> MistralAIProvider::getInstalledModels(const QString &url)
{
QNetworkRequest request(QString("%1/v1/models").arg(url));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
if (!apiKey().isEmpty()) {
request.setRawHeader("Authorization", QString("Bearer %1").arg(apiKey()).toUtf8());
m_client->setUrl(url);
m_client->setApiKey(apiKey());
return m_client->listModels();
}
return httpClient()->get(request).then([](const QByteArray &data) {
QList<QString> models;
QJsonObject jsonObject = QJsonDocument::fromJson(data).object();
if (jsonObject.contains("data") && jsonObject["object"].toString() == "list") {
QJsonArray modelArray = jsonObject["data"].toArray();
for (const QJsonValue &value : modelArray) {
QJsonObject modelObject = value.toObject();
if (modelObject.contains("id")) {
models.append(modelObject["id"].toString());
}
}
}
return models;
}).onFailed([](const std::exception &e) {
LOG_MESSAGE(QString("Error fetching Mistral AI models: %1").arg(e.what()));
return QList<QString>{};
});
}
QList<QString> MistralAIProvider::validateRequest(
const QJsonObject &request, LLMCore::TemplateType type)
PluginLLMCore::ProviderID MistralAIProvider::providerID() const
{
const auto fimReq = QJsonObject{
{"model", {}},
{"max_tokens", {}},
{"stream", {}},
{"temperature", {}},
{"prompt", {}},
{"suffix", {}}};
const auto templateReq = QJsonObject{
{"model", {}},
{"messages", QJsonArray{{QJsonObject{{"role", {}}, {"content", {}}}}}},
{"temperature", {}},
{"max_tokens", {}},
{"top_p", {}},
{"top_k", {}},
{"frequency_penalty", {}},
{"presence_penalty", {}},
{"stop", QJsonArray{}},
{"stream", {}},
{"tools", {}}};
return LLMCore::ValidationUtils::validateRequestFields(
request, type == LLMCore::TemplateType::FIM ? fimReq : templateReq);
return PluginLLMCore::ProviderID::MistralAI;
}
QString MistralAIProvider::apiKey() const
PluginLLMCore::ProviderCapabilities MistralAIProvider::capabilities() const
{
return Settings::providerSettings().mistralAiApiKey();
}
void MistralAIProvider::prepareNetworkRequest(QNetworkRequest &networkRequest) const
{
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
if (!apiKey().isEmpty()) {
networkRequest.setRawHeader("Authorization", QString("Bearer %1").arg(apiKey()).toUtf8());
}
}
LLMCore::ProviderID MistralAIProvider::providerID() const
{
return LLMCore::ProviderID::MistralAI;
}
void MistralAIProvider::sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload)
{
if (!m_messages.contains(requestId)) {
m_dataBuffers[requestId].clear();
}
m_requestUrls[requestId] = url;
m_originalRequests[requestId] = payload;
QNetworkRequest networkRequest(url);
prepareNetworkRequest(networkRequest);
LOG_MESSAGE(
QString("MistralAIProvider: Sending request %1 to %2").arg(requestId, url.toString()));
httpClient()->postStreaming(requestId, networkRequest, payload);
}
bool MistralAIProvider::supportsTools() const
{
return true;
}
bool MistralAIProvider::supportImage() const
{
return true;
}
void MistralAIProvider::cancelRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("MistralAIProvider: Cancelling request %1").arg(requestId));
LLMCore::Provider::cancelRequest(requestId);
cleanupRequest(requestId);
}
void MistralAIProvider::onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data)
{
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
QStringList lines = buffers.rawStreamBuffer.processData(data);
for (const QString &line : lines) {
if (line.trimmed().isEmpty() || line == "data: [DONE]") {
continue;
}
QJsonObject chunk = parseEventLine(line);
if (chunk.isEmpty())
continue;
processStreamChunk(requestId, chunk);
}
}
void MistralAIProvider::onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId, std::optional<QString> error)
{
if (error) {
LOG_MESSAGE(QString("MistralAIProvider request %1 failed: %2").arg(requestId, *error));
emit requestFailed(requestId, *error);
cleanupRequest(requestId);
return;
}
if (m_messages.contains(requestId)) {
OpenAIMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Waiting for tools to complete for %1").arg(requestId));
m_dataBuffers.remove(requestId);
return;
}
}
if (m_dataBuffers.contains(requestId)) {
const LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
if (!buffers.responseContent.isEmpty()) {
LOG_MESSAGE(QString("Emitting full response for %1").arg(requestId));
emit fullResponseReceived(requestId, buffers.responseContent);
}
}
cleanupRequest(requestId);
return PluginLLMCore::ProviderCapability::Tools | PluginLLMCore::ProviderCapability::Image
| PluginLLMCore::ProviderCapability::ModelListing;
}
void MistralAIProvider::prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
{
@@ -257,22 +112,16 @@ void MistralAIProvider::prepareRequest(
request["presence_penalty"] = settings.presencePenalty();
};
if (type == LLMCore::RequestType::CodeCompletion) {
if (type == PluginLLMCore::RequestType::CodeCompletion) {
applyModelParams(Settings::codeCompletionSettings());
} else if (type == LLMCore::RequestType::QuickRefactoring) {
} else if (type == PluginLLMCore::RequestType::QuickRefactoring) {
applyModelParams(Settings::quickRefactorSettings());
} else {
applyModelParams(Settings::chatAssistantSettings());
}
if (isToolsEnabled) {
LLMCore::RunToolsFilter filter = LLMCore::RunToolsFilter::ALL;
if (type == LLMCore::RequestType::QuickRefactoring) {
filter = LLMCore::RunToolsFilter::OnlyRead;
}
auto toolsDefinitions = m_toolsManager->getToolsDefinitions(
LLMCore::ToolSchemaFormat::OpenAI, filter);
auto toolsDefinitions = m_client->tools()->getToolsDefinitions();
if (!toolsDefinitions.isEmpty()) {
request["tools"] = toolsDefinitions;
LOG_MESSAGE(QString("Added %1 tools to Mistral request").arg(toolsDefinitions.size()));
@@ -280,163 +129,9 @@ void MistralAIProvider::prepareRequest(
}
}
void MistralAIProvider::onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults)
::LLMCore::BaseClient *MistralAIProvider::client() const
{
if (!m_messages.contains(requestId) || !m_requestUrls.contains(requestId)) {
LOG_MESSAGE(QString("ERROR: Missing data for continuation request %1").arg(requestId));
cleanupRequest(requestId);
return;
}
LOG_MESSAGE(QString("Tool execution complete for Mistral request %1").arg(requestId));
for (auto it = toolResults.begin(); it != toolResults.end(); ++it) {
OpenAIMessage *message = m_messages[requestId];
auto toolContent = message->getCurrentToolUseContent();
for (auto tool : toolContent) {
if (tool->id() == it.key()) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(tool->name());
emit toolExecutionCompleted(
requestId, tool->id(), toolStringName, toolResults[tool->id()]);
break;
}
}
}
OpenAIMessage *message = m_messages[requestId];
QJsonObject continuationRequest = m_originalRequests[requestId];
QJsonArray messages = continuationRequest["messages"].toArray();
messages.append(message->toProviderFormat());
QJsonArray toolResultMessages = message->createToolResultMessages(toolResults);
for (const auto &toolMsg : toolResultMessages) {
messages.append(toolMsg);
}
continuationRequest["messages"] = messages;
LOG_MESSAGE(QString("Sending continuation request for %1 with %2 tool results")
.arg(requestId)
.arg(toolResults.size()));
sendRequest(requestId, m_requestUrls[requestId], continuationRequest);
}
void MistralAIProvider::processStreamChunk(const QString &requestId, const QJsonObject &chunk)
{
QJsonArray choices = chunk["choices"].toArray();
if (choices.isEmpty()) {
return;
}
QJsonObject choice = choices[0].toObject();
QJsonObject delta = choice["delta"].toObject();
QString finishReason = choice["finish_reason"].toString();
OpenAIMessage *message = m_messages.value(requestId);
if (!message) {
message = new OpenAIMessage(this);
m_messages[requestId] = message;
LOG_MESSAGE(QString("Created NEW OpenAIMessage for Mistral request %1").arg(requestId));
if (m_dataBuffers.contains(requestId)) {
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Starting continuation for request %1").arg(requestId));
}
} else if (
m_dataBuffers.contains(requestId)
&& message->state() == LLMCore::MessageState::RequiresToolExecution) {
message->startNewContinuation();
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Cleared message state for continuation request %1").arg(requestId));
}
if (delta.contains("content") && !delta["content"].isNull()) {
QString content = delta["content"].toString();
message->handleContentDelta(content);
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
buffers.responseContent += content;
emit partialResponseReceived(requestId, content);
}
if (delta.contains("tool_calls")) {
QJsonArray toolCalls = delta["tool_calls"].toArray();
for (const auto &toolCallValue : toolCalls) {
QJsonObject toolCall = toolCallValue.toObject();
int index = toolCall["index"].toInt();
if (toolCall.contains("id")) {
QString id = toolCall["id"].toString();
QJsonObject function = toolCall["function"].toObject();
QString name = function["name"].toString();
message->handleToolCallStart(index, id, name);
}
if (toolCall.contains("function")) {
QJsonObject function = toolCall["function"].toObject();
if (function.contains("arguments")) {
QString args = function["arguments"].toString();
message->handleToolCallDelta(index, args);
}
}
}
}
if (!finishReason.isEmpty() && finishReason != "null") {
for (int i = 0; i < 10; ++i) {
message->handleToolCallComplete(i);
}
message->handleFinishReason(finishReason);
handleMessageComplete(requestId);
}
}
void MistralAIProvider::handleMessageComplete(const QString &requestId)
{
if (!m_messages.contains(requestId))
return;
OpenAIMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Mistral message requires tool execution for %1").arg(requestId));
auto toolUseContent = message->getCurrentToolUseContent();
if (toolUseContent.isEmpty()) {
LOG_MESSAGE(QString("No tools to execute for %1").arg(requestId));
return;
}
for (auto toolContent : toolUseContent) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(toolContent->name());
emit toolExecutionStarted(requestId, toolContent->id(), toolStringName);
m_toolsManager->executeToolCall(
requestId, toolContent->id(), toolContent->name(), toolContent->input());
}
} else {
LOG_MESSAGE(QString("Mistral message marked as complete for %1").arg(requestId));
}
}
void MistralAIProvider::cleanupRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("Cleaning up Mistral request %1").arg(requestId));
if (m_messages.contains(requestId)) {
OpenAIMessage *message = m_messages.take(requestId);
message->deleteLater();
}
m_dataBuffers.remove(requestId);
m_requestUrls.remove(requestId);
m_originalRequests.remove(requestId);
m_toolsManager->cleanupRequest(requestId);
return m_client;
}
} // namespace QodeAssist::Providers

48
providers/MistralAIProvider.hpp
View File

@@ -19,13 +19,12 @@
#pragma once
#include "OpenAIMessage.hpp"
#include "tools/ToolsManager.hpp"
#include <llmcore/Provider.hpp>
#include <LLMCore/OpenAIClient.hpp>
#include <pluginllmcore/Provider.hpp>
namespace QodeAssist::Providers {
class MistralAIProvider : public LLMCore::Provider
class MistralAIProvider : public PluginLLMCore::Provider
{
Q_OBJECT
public:
@@ -35,47 +34,22 @@ public:
QString url() const override;
QString completionEndpoint() const override;
QString chatEndpoint() const override;
bool supportsModelListing() const override;
void prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled) override;
QFuture<QList<QString>> getInstalledModels(const QString &url) override;
QList<QString> validateRequest(const QJsonObject &request, LLMCore::TemplateType type) override;
PluginLLMCore::ProviderID providerID() const override;
PluginLLMCore::ProviderCapabilities capabilities() const override;
::LLMCore::BaseClient *client() const override;
QString apiKey() const override;
void prepareNetworkRequest(QNetworkRequest &networkRequest) const override;
LLMCore::ProviderID providerID() const override;
void sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload) override;
bool supportsTools() const override;
bool supportImage() const override;
void cancelRequest(const LLMCore::RequestID &requestId) override;
public slots:
void onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data) override;
void onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId,
std::optional<QString> error) override;
private slots:
void onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults);
private:
void processStreamChunk(const QString &requestId, const QJsonObject &chunk);
void handleMessageComplete(const QString &requestId);
void cleanupRequest(const LLMCore::RequestID &requestId);
QHash<LLMCore::RequestID, OpenAIMessage *> m_messages;
QHash<LLMCore::RequestID, QUrl> m_requestUrls;
QHash<LLMCore::RequestID, QJsonObject> m_originalRequests;
Tools::ToolsManager *m_toolsManager;
::LLMCore::OpenAIClient *m_client;
};
} // namespace QodeAssist::Providers

52
providers/OllamaMessage.cpp
View File

@@ -39,13 +39,13 @@ void OllamaMessage::handleContentDelta(const QString &content)
}
if (!m_contentAddedToTextBlock) {
LLMCore::TextContent *textContent = getOrCreateTextContent();
PluginLLMCore::TextContent *textContent = getOrCreateTextContent();
textContent->setText(m_accumulatedContent);
m_contentAddedToTextBlock = true;
LOG_MESSAGE(QString("OllamaMessage: Added accumulated content to TextContent, length=%1")
.arg(m_accumulatedContent.length()));
} else {
LLMCore::TextContent *textContent = getOrCreateTextContent();
PluginLLMCore::TextContent *textContent = getOrCreateTextContent();
textContent->appendText(content);
}
}
@@ -65,7 +65,7 @@ void OllamaMessage::handleToolCall(const QJsonObject &toolCall)
m_accumulatedContent.clear();
}
addCurrentContent<LLMCore::ToolUseContent>(toolId, name, arguments);
addCurrentContent<PluginLLMCore::ToolUseContent>(toolId, name, arguments);
LOG_MESSAGE(
QString("OllamaMessage: Structured tool call detected - name=%1, id=%2").arg(name, toolId));
@@ -73,7 +73,7 @@ void OllamaMessage::handleToolCall(const QJsonObject &toolCall)
void OllamaMessage::handleThinkingDelta(const QString &thinking)
{
LLMCore::ThinkingContent *thinkingContent = getOrCreateThinkingContent();
PluginLLMCore::ThinkingContent *thinkingContent = getOrCreateThinkingContent();
thinkingContent->appendThinking(thinking);
}
@@ -102,7 +102,7 @@ void OllamaMessage::handleDone(bool done)
.arg(trimmed.length()));
for (auto it = m_currentBlocks.begin(); it != m_currentBlocks.end();) {
if (qobject_cast<LLMCore::TextContent *>(*it)) {
if (qobject_cast<PluginLLMCore::TextContent *>(*it)) {
LOG_MESSAGE(QString(
"OllamaMessage: Removing TextContent block (incomplete tool call)"));
(*it)->deleteLater();
@@ -114,7 +114,7 @@ void OllamaMessage::handleDone(bool done)
m_accumulatedContent.clear();
} else {
LLMCore::TextContent *textContent = getOrCreateTextContent();
PluginLLMCore::TextContent *textContent = getOrCreateTextContent();
textContent->setText(m_accumulatedContent);
m_contentAddedToTextBlock = true;
LOG_MESSAGE(
@@ -184,13 +184,13 @@ bool OllamaMessage::tryParseToolCall()
QString toolId = QString("call_%1_%2").arg(name).arg(QDateTime::currentMSecsSinceEpoch());
for (auto block : m_currentBlocks) {
if (qobject_cast<LLMCore::TextContent *>(block)) {
if (qobject_cast<PluginLLMCore::TextContent *>(block)) {
LOG_MESSAGE(QString("OllamaMessage: Removing TextContent block (tool call detected)"));
}
}
m_currentBlocks.clear();
addCurrentContent<LLMCore::ToolUseContent>(toolId, name, arguments);
addCurrentContent<PluginLLMCore::ToolUseContent>(toolId, name, arguments);
LOG_MESSAGE(
QString(
@@ -238,14 +238,14 @@ QJsonObject OllamaMessage::toProviderFormat() const
if (!block)
continue;
if (auto text = qobject_cast<LLMCore::TextContent *>(block)) {
if (auto text = qobject_cast<PluginLLMCore::TextContent *>(block)) {
textContent += text->text();
} else if (auto tool = qobject_cast<LLMCore::ToolUseContent *>(block)) {
} else if (auto tool = qobject_cast<PluginLLMCore::ToolUseContent *>(block)) {
QJsonObject toolCall;
toolCall["type"] = "function";
toolCall["function"] = QJsonObject{{"name", tool->name()}, {"arguments", tool->input()}};
toolCalls.append(toolCall);
} else if (auto thinking = qobject_cast<LLMCore::ThinkingContent *>(block)) {
} else if (auto thinking = qobject_cast<PluginLLMCore::ThinkingContent *>(block)) {
thinkingContent += thinking->thinking();
}
}
@@ -287,22 +287,22 @@ QJsonArray OllamaMessage::createToolResultMessages(const QHash<QString, QString>
return messages;
}
QList<LLMCore::ToolUseContent *> OllamaMessage::getCurrentToolUseContent() const
QList<PluginLLMCore::ToolUseContent *> OllamaMessage::getCurrentToolUseContent() const
{
QList<LLMCore::ToolUseContent *> toolBlocks;
QList<PluginLLMCore::ToolUseContent *> toolBlocks;
for (auto block : m_currentBlocks) {
if (auto toolContent = qobject_cast<LLMCore::ToolUseContent *>(block)) {
if (auto toolContent = qobject_cast<PluginLLMCore::ToolUseContent *>(block)) {
toolBlocks.append(toolContent);
}
}
return toolBlocks;
}
QList<LLMCore::ThinkingContent *> OllamaMessage::getCurrentThinkingContent() const
QList<PluginLLMCore::ThinkingContent *> OllamaMessage::getCurrentThinkingContent() const
{
QList<LLMCore::ThinkingContent *> thinkingBlocks;
QList<PluginLLMCore::ThinkingContent *> thinkingBlocks;
for (auto block : m_currentBlocks) {
if (auto thinkingContent = qobject_cast<LLMCore::ThinkingContent *>(block)) {
if (auto thinkingContent = qobject_cast<PluginLLMCore::ThinkingContent *>(block)) {
thinkingBlocks.append(thinkingContent);
}
}
@@ -316,7 +316,7 @@ void OllamaMessage::startNewContinuation()
m_currentBlocks.clear();
m_accumulatedContent.clear();
m_done = false;
m_state = LLMCore::MessageState::Building;
m_state = PluginLLMCore::MessageState::Building;
m_contentAddedToTextBlock = false;
m_currentThinkingContent = nullptr;
}
@@ -324,40 +324,40 @@ void OllamaMessage::startNewContinuation()
void OllamaMessage::updateStateFromDone()
{
if (!getCurrentToolUseContent().empty()) {
m_state = LLMCore::MessageState::RequiresToolExecution;
m_state = PluginLLMCore::MessageState::RequiresToolExecution;
LOG_MESSAGE(QString("OllamaMessage: State set to RequiresToolExecution, tools count=%1")
.arg(getCurrentToolUseContent().size()));
} else {
m_state = LLMCore::MessageState::Final;
m_state = PluginLLMCore::MessageState::Final;
LOG_MESSAGE(QString("OllamaMessage: State set to Final"));
}
}
LLMCore::TextContent *OllamaMessage::getOrCreateTextContent()
PluginLLMCore::TextContent *OllamaMessage::getOrCreateTextContent()
{
for (auto block : m_currentBlocks) {
if (auto textContent = qobject_cast<LLMCore::TextContent *>(block)) {
if (auto textContent = qobject_cast<PluginLLMCore::TextContent *>(block)) {
return textContent;
}
}
return addCurrentContent<LLMCore::TextContent>();
return addCurrentContent<PluginLLMCore::TextContent>();
}
LLMCore::ThinkingContent *OllamaMessage::getOrCreateThinkingContent()
PluginLLMCore::ThinkingContent *OllamaMessage::getOrCreateThinkingContent()
{
if (m_currentThinkingContent) {
return m_currentThinkingContent;
}
for (auto block : m_currentBlocks) {
if (auto thinkingContent = qobject_cast<LLMCore::ThinkingContent *>(block)) {
if (auto thinkingContent = qobject_cast<PluginLLMCore::ThinkingContent *>(block)) {
m_currentThinkingContent = thinkingContent;
return m_currentThinkingContent;
}
}
m_currentThinkingContent = addCurrentContent<LLMCore::ThinkingContent>();
m_currentThinkingContent = addCurrentContent<PluginLLMCore::ThinkingContent>();
LOG_MESSAGE(QString("OllamaMessage: Created new ThinkingContent block"));
return m_currentThinkingContent;
}

20
providers/OllamaMessage.hpp
View File

@@ -19,7 +19,7 @@
#pragma once
#include <llmcore/ContentBlocks.hpp>
#include <pluginllmcore/ContentBlocks.hpp>
namespace QodeAssist::Providers {
@@ -38,26 +38,26 @@ public:
QJsonObject toProviderFormat() const;
QJsonArray createToolResultMessages(const QHash<QString, QString> &toolResults) const;
LLMCore::MessageState state() const { return m_state; }
QList<LLMCore::ToolUseContent *> getCurrentToolUseContent() const;
QList<LLMCore::ThinkingContent *> getCurrentThinkingContent() const;
QList<LLMCore::ContentBlock *> currentBlocks() const { return m_currentBlocks; }
PluginLLMCore::MessageState state() const { return m_state; }
QList<PluginLLMCore::ToolUseContent *> getCurrentToolUseContent() const;
QList<PluginLLMCore::ThinkingContent *> getCurrentThinkingContent() const;
QList<PluginLLMCore::ContentBlock *> currentBlocks() const { return m_currentBlocks; }
void startNewContinuation();
private:
bool m_done = false;
LLMCore::MessageState m_state = LLMCore::MessageState::Building;
QList<LLMCore::ContentBlock *> m_currentBlocks;
PluginLLMCore::MessageState m_state = PluginLLMCore::MessageState::Building;
QList<PluginLLMCore::ContentBlock *> m_currentBlocks;
QString m_accumulatedContent;
bool m_contentAddedToTextBlock = false;
LLMCore::ThinkingContent *m_currentThinkingContent = nullptr;
PluginLLMCore::ThinkingContent *m_currentThinkingContent = nullptr;
void updateStateFromDone();
bool tryParseToolCall();
bool isLikelyToolCallJson(const QString &content) const;
LLMCore::TextContent *getOrCreateTextContent();
LLMCore::ThinkingContent *getOrCreateThinkingContent();
PluginLLMCore::TextContent *getOrCreateTextContent();
PluginLLMCore::ThinkingContent *getOrCreateThinkingContent();
template<typename T, typename... Args>
T *addCurrentContent(Args &&...args)

491
providers/OllamaProvider.cpp
View File

@@ -19,29 +19,27 @@
#include "OllamaProvider.hpp"
#include <LLMCore/ToolsManager.hpp>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include "llmcore/ValidationUtils.hpp"
#include "logger/Logger.hpp"
#include "settings/ChatAssistantSettings.hpp"
#include "settings/CodeCompletionSettings.hpp"
#include "settings/QuickRefactorSettings.hpp"
#include "settings/GeneralSettings.hpp"
#include "settings/ProviderSettings.hpp"
#include "tools/ToolsRegistration.hpp"
namespace QodeAssist::Providers {
OllamaProvider::OllamaProvider(QObject *parent)
: LLMCore::Provider(parent)
, m_toolsManager(new Tools::ToolsManager(this))
: PluginLLMCore::Provider(parent)
, m_client(new ::LLMCore::OllamaClient(QString(), QString(), QString(), this))
{
connect(
m_toolsManager,
&Tools::ToolsManager::toolExecutionComplete,
this,
&OllamaProvider::onToolExecutionComplete);
Tools::registerQodeAssistTools(m_client->tools());
}
QString OllamaProvider::name() const
@@ -49,6 +47,11 @@ QString OllamaProvider::name() const
return "Ollama";
}
QString OllamaProvider::apiKey() const
{
return Settings::providerSettings().ollamaBasicAuthApiKey();
}
QString OllamaProvider::url() const
{
return "http://localhost:11434";
@@ -64,16 +67,11 @@ QString OllamaProvider::chatEndpoint() const
return "/api/chat";
}
bool OllamaProvider::supportsModelListing() const
{
return true;
}
void OllamaProvider::prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
{
@@ -109,9 +107,9 @@ void OllamaProvider::prepareRequest(
request["options"] = options;
};
if (type == LLMCore::RequestType::CodeCompletion) {
if (type == PluginLLMCore::RequestType::CodeCompletion) {
applySettings(Settings::codeCompletionSettings());
} else if (type == LLMCore::RequestType::QuickRefactoring) {
} else if (type == PluginLLMCore::RequestType::QuickRefactoring) {
const auto &qrSettings = Settings::quickRefactorSettings();
applySettings(qrSettings);
@@ -130,13 +128,7 @@ void OllamaProvider::prepareRequest(
}
if (isToolsEnabled) {
LLMCore::RunToolsFilter filter = LLMCore::RunToolsFilter::ALL;
if (type == LLMCore::RequestType::QuickRefactoring) {
filter = LLMCore::RunToolsFilter::OnlyRead;
}
auto toolsDefinitions = m_toolsManager->toolsFactory()->getToolsDefinitions(
LLMCore::ToolSchemaFormat::Ollama, filter);
auto toolsDefinitions = m_client->tools()->getToolsDefinitions();
if (!toolsDefinitions.isEmpty()) {
request["tools"] = toolsDefinitions;
LOG_MESSAGE(
@@ -145,453 +137,28 @@ void OllamaProvider::prepareRequest(
}
}
QFuture<QList<QString>> OllamaProvider::getInstalledModels(const QString &url)
QFuture<QList<QString>> OllamaProvider::getInstalledModels(const QString &baseUrl)
{
QNetworkRequest request(QString("%1%2").arg(url, "/api/tags"));
prepareNetworkRequest(request);
return httpClient()->get(request).then([](const QByteArray &data) {
QList<QString> models;
QJsonObject jsonObject = QJsonDocument::fromJson(data).object();
QJsonArray modelArray = jsonObject["models"].toArray();
for (const QJsonValue &value : modelArray) {
QJsonObject modelObject = value.toObject();
models.append(modelObject["name"].toString());
}
return models;
}).onFailed([](const std::exception &e) {
LOG_MESSAGE(QString("Error fetching models: %1").arg(e.what()));
return QList<QString>{};
});
m_client->setUrl(baseUrl);
m_client->setApiKey(Settings::providerSettings().ollamaBasicAuthApiKey());
return m_client->listModels();
}
QList<QString> OllamaProvider::validateRequest(const QJsonObject &request, LLMCore::TemplateType type)
PluginLLMCore::ProviderID OllamaProvider::providerID() const
{
const auto fimReq = QJsonObject{
{"keep_alive", {}},
{"model", {}},
{"stream", {}},
{"prompt", {}},
{"suffix", {}},
{"system", {}},
{"images", QJsonArray{}},
{"options",
QJsonObject{
{"temperature", {}},
{"stop", {}},
{"top_p", {}},
{"top_k", {}},
{"num_predict", {}},
{"frequency_penalty", {}},
{"presence_penalty", {}}}}};
const auto messageReq = QJsonObject{
{"keep_alive", {}},
{"model", {}},
{"stream", {}},
{"messages", QJsonArray{{QJsonObject{{"role", {}}, {"content", {}}, {"images", QJsonArray{}}}}}},
{"tools", QJsonArray{}},
{"options",
QJsonObject{
{"temperature", {}},
{"stop", {}},
{"top_p", {}},
{"top_k", {}},
{"num_predict", {}},
{"frequency_penalty", {}},
{"presence_penalty", {}}}}};
return LLMCore::ValidationUtils::validateRequestFields(
request, type == LLMCore::TemplateType::FIM ? fimReq : messageReq);
return PluginLLMCore::ProviderID::Ollama;
}
QString OllamaProvider::apiKey() const
PluginLLMCore::ProviderCapabilities OllamaProvider::capabilities() const
{
return {};
return PluginLLMCore::ProviderCapability::Tools | PluginLLMCore::ProviderCapability::Thinking
| PluginLLMCore::ProviderCapability::Image
| PluginLLMCore::ProviderCapability::ModelListing;
}
void OllamaProvider::prepareNetworkRequest(QNetworkRequest &networkRequest) const
::LLMCore::BaseClient *OllamaProvider::client() const
{
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
const auto key = Settings::providerSettings().ollamaBasicAuthApiKey();
if (!key.isEmpty()) {
networkRequest.setRawHeader("Authorization", "Basic " + key.toLatin1());
}
}
LLMCore::ProviderID OllamaProvider::providerID() const
{
return LLMCore::ProviderID::Ollama;
}
void OllamaProvider::sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload)
{
m_dataBuffers[requestId].clear();
m_requestUrls[requestId] = url;
m_originalRequests[requestId] = payload;
QNetworkRequest networkRequest(url);
prepareNetworkRequest(networkRequest);
LOG_MESSAGE(QString("OllamaProvider: Sending request %1 to %2").arg(requestId, url.toString()));
httpClient()->postStreaming(requestId, networkRequest, payload);
}
bool OllamaProvider::supportsTools() const
{
return true;
}
bool OllamaProvider::supportImage() const
{
return true;
}
bool OllamaProvider::supportThinking() const
{
return true;
}
void OllamaProvider::cancelRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("OllamaProvider: Cancelling request %1").arg(requestId));
LLMCore::Provider::cancelRequest(requestId);
cleanupRequest(requestId);
}
void OllamaProvider::onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data)
{
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
QStringList lines = buffers.rawStreamBuffer.processData(data);
if (data.isEmpty()) {
return;
}
for (const QString &line : lines) {
if (line.trimmed().isEmpty()) {
continue;
}
QJsonParseError error;
QJsonDocument doc = QJsonDocument::fromJson(line.toUtf8(), &error);
if (doc.isNull()) {
LOG_MESSAGE(QString("Failed to parse JSON: %1").arg(error.errorString()));
continue;
}
QJsonObject obj = doc.object();
if (obj.contains("error") && !obj["error"].toString().isEmpty()) {
LOG_MESSAGE("Error in Ollama response: " + obj["error"].toString());
continue;
}
processStreamData(requestId, obj);
}
}
void OllamaProvider::onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId, std::optional<QString> error)
{
if (error) {
LOG_MESSAGE(QString("OllamaProvider request %1 failed: %2").arg(requestId, *error));
emit requestFailed(requestId, *error);
cleanupRequest(requestId);
return;
}
if (m_messages.contains(requestId)) {
OllamaMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Waiting for tools to complete for %1").arg(requestId));
return;
}
}
QString finalText;
if (m_messages.contains(requestId)) {
OllamaMessage *message = m_messages[requestId];
for (auto block : message->currentBlocks()) {
if (auto textContent = qobject_cast<LLMCore::TextContent *>(block)) {
finalText += textContent->text();
}
}
if (!finalText.isEmpty()) {
LOG_MESSAGE(QString("Emitting full response for %1, length=%2")
.arg(requestId)
.arg(finalText.length()));
emit fullResponseReceived(requestId, finalText);
}
}
cleanupRequest(requestId);
}
void OllamaProvider::onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults)
{
if (!m_messages.contains(requestId)) {
LOG_MESSAGE(QString("ERROR: No message found for request %1").arg(requestId));
cleanupRequest(requestId);
return;
}
if (!m_requestUrls.contains(requestId) || !m_originalRequests.contains(requestId)) {
LOG_MESSAGE(QString("ERROR: Missing data for continuation request %1").arg(requestId));
cleanupRequest(requestId);
return;
}
LOG_MESSAGE(QString("Tool execution complete for Ollama request %1").arg(requestId));
OllamaMessage *message = m_messages[requestId];
for (auto it = toolResults.begin(); it != toolResults.end(); ++it) {
auto toolContent = message->getCurrentToolUseContent();
for (auto tool : toolContent) {
if (tool->id() == it.key()) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(tool->name());
emit toolExecutionCompleted(requestId, tool->id(), toolStringName, it.value());
break;
}
}
}
QJsonObject continuationRequest = m_originalRequests[requestId];
QJsonArray messages = continuationRequest["messages"].toArray();
QJsonObject assistantMessage = message->toProviderFormat();
messages.append(assistantMessage);
LOG_MESSAGE(QString("Assistant message with tool_calls:\n%1")
.arg(
QString::fromUtf8(
QJsonDocument(assistantMessage).toJson(QJsonDocument::Indented))));
QJsonArray toolResultMessages = message->createToolResultMessages(toolResults);
for (const auto &toolMsg : toolResultMessages) {
messages.append(toolMsg);
LOG_MESSAGE(QString("Tool result message:\n%1")
.arg(
QString::fromUtf8(
QJsonDocument(toolMsg.toObject()).toJson(QJsonDocument::Indented))));
}
continuationRequest["messages"] = messages;
LOG_MESSAGE(QString("Sending continuation request for %1 with %2 tool results")
.arg(requestId)
.arg(toolResults.size()));
sendRequest(requestId, m_requestUrls[requestId], continuationRequest);
}
void OllamaProvider::processStreamData(const QString &requestId, const QJsonObject &data)
{
OllamaMessage *message = m_messages.value(requestId);
if (!message) {
message = new OllamaMessage(this);
m_messages[requestId] = message;
LOG_MESSAGE(QString("Created NEW OllamaMessage for request %1").arg(requestId));
if (m_dataBuffers.contains(requestId)) {
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Starting continuation for request %1").arg(requestId));
}
} else if (
m_dataBuffers.contains(requestId)
&& message->state() == LLMCore::MessageState::RequiresToolExecution) {
message->startNewContinuation();
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Cleared message state for continuation request %1").arg(requestId));
}
if (data.contains("thinking")) {
QString thinkingDelta = data["thinking"].toString();
if (!thinkingDelta.isEmpty()) {
message->handleThinkingDelta(thinkingDelta);
LOG_MESSAGE(QString("OllamaProvider: Received thinking delta, length=%1")
.arg(thinkingDelta.length()));
}
}
if (data.contains("message")) {
QJsonObject messageObj = data["message"].toObject();
if (messageObj.contains("thinking")) {
QString thinkingDelta = messageObj["thinking"].toString();
if (!thinkingDelta.isEmpty()) {
message->handleThinkingDelta(thinkingDelta);
if (!m_thinkingStarted.contains(requestId)) {
auto thinkingBlocks = message->getCurrentThinkingContent();
if (!thinkingBlocks.isEmpty() && thinkingBlocks.first()) {
QString currentThinking = thinkingBlocks.first()->thinking();
QString displayThinking = currentThinking.length() > 50
? QString("%1...").arg(currentThinking.left(50))
: currentThinking;
emit thinkingBlockReceived(requestId, displayThinking, "");
m_thinkingStarted.insert(requestId);
}
}
}
}
if (messageObj.contains("content")) {
QString content = messageObj["content"].toString();
if (!content.isEmpty()) {
emitThinkingBlocks(requestId, message);
message->handleContentDelta(content);
bool hasTextContent = false;
for (auto block : message->currentBlocks()) {
if (qobject_cast<LLMCore::TextContent *>(block)) {
hasTextContent = true;
break;
}
}
if (hasTextContent) {
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
buffers.responseContent += content;
emit partialResponseReceived(requestId, content);
}
}
}
if (messageObj.contains("tool_calls")) {
QJsonArray toolCalls = messageObj["tool_calls"].toArray();
LOG_MESSAGE(
QString("OllamaProvider: Found %1 structured tool calls").arg(toolCalls.size()));
for (const auto &toolCallValue : toolCalls) {
message->handleToolCall(toolCallValue.toObject());
}
}
}
else if (data.contains("response")) {
QString content = data["response"].toString();
if (!content.isEmpty()) {
message->handleContentDelta(content);
bool hasTextContent = false;
for (auto block : message->currentBlocks()) {
if (qobject_cast<LLMCore::TextContent *>(block)) {
hasTextContent = true;
break;
}
}
if (hasTextContent) {
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
buffers.responseContent += content;
emit partialResponseReceived(requestId, content);
}
}
}
if (data["done"].toBool()) {
if (data.contains("signature")) {
QString signature = data["signature"].toString();
message->handleThinkingComplete(signature);
LOG_MESSAGE(QString("OllamaProvider: Set thinking signature, length=%1")
.arg(signature.length()));
}
message->handleDone(true);
handleMessageComplete(requestId);
}
}
void OllamaProvider::handleMessageComplete(const QString &requestId)
{
if (!m_messages.contains(requestId))
return;
OllamaMessage *message = m_messages[requestId];
emitThinkingBlocks(requestId, message);
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Ollama message requires tool execution for %1").arg(requestId));
auto toolUseContent = message->getCurrentToolUseContent();
if (toolUseContent.isEmpty()) {
LOG_MESSAGE(
QString("WARNING: No tools to execute for %1 despite RequiresToolExecution state")
.arg(requestId));
return;
}
for (auto toolContent : toolUseContent) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(toolContent->name());
emit toolExecutionStarted(requestId, toolContent->id(), toolStringName);
LOG_MESSAGE(
QString("Executing tool: name=%1, id=%2, input=%3")
.arg(toolContent->name())
.arg(toolContent->id())
.arg(
QString::fromUtf8(
QJsonDocument(toolContent->input()).toJson(QJsonDocument::Compact))));
m_toolsManager->executeToolCall(
requestId, toolContent->id(), toolContent->name(), toolContent->input());
}
} else {
LOG_MESSAGE(QString("Ollama message marked as complete for %1").arg(requestId));
}
}
void OllamaProvider::cleanupRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("Cleaning up Ollama request %1").arg(requestId));
if (m_messages.contains(requestId)) {
auto msg = m_messages.take(requestId);
msg->deleteLater();
}
m_dataBuffers.remove(requestId);
m_requestUrls.remove(requestId);
m_originalRequests.remove(requestId);
m_thinkingEmitted.remove(requestId);
m_thinkingStarted.remove(requestId);
m_toolsManager->cleanupRequest(requestId);
}
void OllamaProvider::emitThinkingBlocks(const QString &requestId, OllamaMessage *message)
{
if (!message || m_thinkingEmitted.contains(requestId)) {
return;
}
auto thinkingBlocks = message->getCurrentThinkingContent();
if (thinkingBlocks.isEmpty()) {
return;
}
for (auto thinkingContent : thinkingBlocks) {
emit thinkingBlockReceived(
requestId, thinkingContent->thinking(), thinkingContent->signature());
LOG_MESSAGE(QString("Emitted thinking block for request %1, thinking length=%2, signature "
"length=%3")
.arg(requestId)
.arg(thinkingContent->thinking().length())
.arg(thinkingContent->signature().length()));
}
m_thinkingEmitted.insert(requestId);
return m_client;
}
} // namespace QodeAssist::Providers

52
providers/OllamaProvider.hpp
View File

@@ -19,14 +19,13 @@
#pragma once
#include <llmcore/Provider.hpp>
#include <pluginllmcore/Provider.hpp>
#include "OllamaMessage.hpp"
#include "tools/ToolsManager.hpp"
#include <LLMCore/OllamaClient.hpp>
namespace QodeAssist::Providers {
class OllamaProvider : public LLMCore::Provider
class OllamaProvider : public PluginLLMCore::Provider
{
Q_OBJECT
public:
@@ -36,51 +35,22 @@ public:
QString url() const override;
QString completionEndpoint() const override;
QString chatEndpoint() const override;
bool supportsModelListing() const override;
void prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled) override;
QFuture<QList<QString>> getInstalledModels(const QString &url) override;
QList<QString> validateRequest(const QJsonObject &request, LLMCore::TemplateType type) override;
PluginLLMCore::ProviderID providerID() const override;
PluginLLMCore::ProviderCapabilities capabilities() const override;
::LLMCore::BaseClient *client() const override;
QString apiKey() const override;
void prepareNetworkRequest(QNetworkRequest &networkRequest) const override;
LLMCore::ProviderID providerID() const override;
void sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload) override;
bool supportsTools() const override;
bool supportImage() const override;
bool supportThinking() const override;
void cancelRequest(const LLMCore::RequestID &requestId) override;
public slots:
void onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data) override;
void onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId,
std::optional<QString> error) override;
private slots:
void onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults);
private:
void processStreamData(const QString &requestId, const QJsonObject &data);
void handleMessageComplete(const QString &requestId);
void cleanupRequest(const LLMCore::RequestID &requestId);
void emitThinkingBlocks(const QString &requestId, OllamaMessage *message);
QHash<QodeAssist::LLMCore::RequestID, OllamaMessage *> m_messages;
QHash<QodeAssist::LLMCore::RequestID, QUrl> m_requestUrls;
QHash<QodeAssist::LLMCore::RequestID, QJsonObject> m_originalRequests;
QSet<QString> m_thinkingEmitted;
QSet<QString> m_thinkingStarted;
Tools::ToolsManager *m_toolsManager;
::LLMCore::OllamaClient *m_client;
};
} // namespace QodeAssist::Providers

321
providers/OpenAICompatProvider.cpp
View File

@@ -18,8 +18,9 @@
*/
#include "OpenAICompatProvider.hpp"
#include <LLMCore/ToolsManager.hpp>
#include "llmcore/ValidationUtils.hpp"
#include "tools/ToolsRegistration.hpp"
#include "logger/Logger.hpp"
#include "settings/ChatAssistantSettings.hpp"
#include "settings/CodeCompletionSettings.hpp"
@@ -30,19 +31,14 @@
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QNetworkReply>
namespace QodeAssist::Providers {
OpenAICompatProvider::OpenAICompatProvider(QObject *parent)
: LLMCore::Provider(parent)
, m_toolsManager(new Tools::ToolsManager(this))
: PluginLLMCore::Provider(parent)
, m_client(new ::LLMCore::OpenAIClient(QString(), QString(), QString(), this))
{
connect(
m_toolsManager,
&Tools::ToolsManager::toolExecutionComplete,
this,
&OpenAICompatProvider::onToolExecutionComplete);
Tools::registerQodeAssistTools(m_client->tools());
}
QString OpenAICompatProvider::name() const
@@ -50,6 +46,11 @@ QString OpenAICompatProvider::name() const
return "OpenAI Compatible";
}
QString OpenAICompatProvider::apiKey() const
{
return Settings::providerSettings().openAiCompatApiKey();
}
QString OpenAICompatProvider::url() const
{
return "http://localhost:1234";
@@ -65,16 +66,11 @@ QString OpenAICompatProvider::chatEndpoint() const
return "/v1/chat/completions";
}
bool OpenAICompatProvider::supportsModelListing() const
{
return false;
}
void OpenAICompatProvider::prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
{
@@ -98,22 +94,16 @@ void OpenAICompatProvider::prepareRequest(
request["presence_penalty"] = settings.presencePenalty();
};
if (type == LLMCore::RequestType::CodeCompletion) {
if (type == PluginLLMCore::RequestType::CodeCompletion) {
applyModelParams(Settings::codeCompletionSettings());
} else if (type == LLMCore::RequestType::QuickRefactoring) {
} else if (type == PluginLLMCore::RequestType::QuickRefactoring) {
applyModelParams(Settings::quickRefactorSettings());
} else {
applyModelParams(Settings::chatAssistantSettings());
}
if (isToolsEnabled) {
LLMCore::RunToolsFilter filter = LLMCore::RunToolsFilter::ALL;
if (type == LLMCore::RequestType::QuickRefactoring) {
filter = LLMCore::RunToolsFilter::OnlyRead;
}
auto toolsDefinitions = m_toolsManager->getToolsDefinitions(
LLMCore::ToolSchemaFormat::OpenAI, filter);
auto toolsDefinitions = m_client->tools()->getToolsDefinitions();
if (!toolsDefinitions.isEmpty()) {
request["tools"] = toolsDefinitions;
LOG_MESSAGE(
@@ -127,286 +117,19 @@ QFuture<QList<QString>> OpenAICompatProvider::getInstalledModels(const QString &
return QtFuture::makeReadyFuture(QList<QString>{});
}
QList<QString> OpenAICompatProvider::validateRequest(
const QJsonObject &request, LLMCore::TemplateType type)
PluginLLMCore::ProviderID OpenAICompatProvider::providerID() const
{
const auto templateReq = QJsonObject{
{"model", {}},
{"messages", QJsonArray{{QJsonObject{{"role", {}}, {"content", {}}}}}},
{"temperature", {}},
{"max_tokens", {}},
{"top_p", {}},
{"top_k", {}},
{"frequency_penalty", {}},
{"presence_penalty", {}},
{"stop", QJsonArray{}},
{"stream", {}},
{"tools", {}}};
return LLMCore::ValidationUtils::validateRequestFields(request, templateReq);
return PluginLLMCore::ProviderID::OpenAICompatible;
}
QString OpenAICompatProvider::apiKey() const
PluginLLMCore::ProviderCapabilities OpenAICompatProvider::capabilities() const
{
return Settings::providerSettings().openAiCompatApiKey();
return PluginLLMCore::ProviderCapability::Tools | PluginLLMCore::ProviderCapability::Image;
}
void OpenAICompatProvider::prepareNetworkRequest(QNetworkRequest &networkRequest) const
::LLMCore::BaseClient *OpenAICompatProvider::client() const
{
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
if (!apiKey().isEmpty()) {
networkRequest.setRawHeader("Authorization", QString("Bearer %1").arg(apiKey()).toUtf8());
}
}
LLMCore::ProviderID OpenAICompatProvider::providerID() const
{
return LLMCore::ProviderID::OpenAICompatible;
}
void OpenAICompatProvider::sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload)
{
if (!m_messages.contains(requestId)) {
m_dataBuffers[requestId].clear();
}
m_requestUrls[requestId] = url;
m_originalRequests[requestId] = payload;
QNetworkRequest networkRequest(url);
prepareNetworkRequest(networkRequest);
LOG_MESSAGE(
QString("OpenAICompatProvider: Sending request %1 to %2").arg(requestId, url.toString()));
httpClient()->postStreaming(requestId, networkRequest, payload);
}
bool OpenAICompatProvider::supportsTools() const
{
return true;
}
bool OpenAICompatProvider::supportImage() const
{
return true;
}
void OpenAICompatProvider::cancelRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("OpenAICompatProvider: Cancelling request %1").arg(requestId));
LLMCore::Provider::cancelRequest(requestId);
cleanupRequest(requestId);
}
void OpenAICompatProvider::onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data)
{
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
QStringList lines = buffers.rawStreamBuffer.processData(data);
for (const QString &line : lines) {
if (line.trimmed().isEmpty() || line == "data: [DONE]") {
continue;
}
QJsonObject chunk = parseEventLine(line);
if (chunk.isEmpty())
continue;
processStreamChunk(requestId, chunk);
}
}
void OpenAICompatProvider::onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId, std::optional<QString> error)
{
if (error) {
LOG_MESSAGE(QString("OpenAICompatProvider request %1 failed: %2").arg(requestId, *error));
emit requestFailed(requestId, *error);
cleanupRequest(requestId);
return;
}
if (m_messages.contains(requestId)) {
OpenAIMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Waiting for tools to complete for %1").arg(requestId));
m_dataBuffers.remove(requestId);
return;
}
}
if (m_dataBuffers.contains(requestId)) {
const LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
if (!buffers.responseContent.isEmpty()) {
LOG_MESSAGE(QString("Emitting full response for %1").arg(requestId));
emit fullResponseReceived(requestId, buffers.responseContent);
}
}
cleanupRequest(requestId);
}
void OpenAICompatProvider::onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults)
{
if (!m_messages.contains(requestId) || !m_requestUrls.contains(requestId)) {
LOG_MESSAGE(QString("ERROR: Missing data for continuation request %1").arg(requestId));
cleanupRequest(requestId);
return;
}
LOG_MESSAGE(QString("Tool execution complete for OpenAICompat request %1").arg(requestId));
for (auto it = toolResults.begin(); it != toolResults.end(); ++it) {
OpenAIMessage *message = m_messages[requestId];
auto toolContent = message->getCurrentToolUseContent();
for (auto tool : toolContent) {
if (tool->id() == it.key()) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(tool->name());
emit toolExecutionCompleted(
requestId, tool->id(), toolStringName, toolResults[tool->id()]);
break;
}
}
}
OpenAIMessage *message = m_messages[requestId];
QJsonObject continuationRequest = m_originalRequests[requestId];
QJsonArray messages = continuationRequest["messages"].toArray();
messages.append(message->toProviderFormat());
QJsonArray toolResultMessages = message->createToolResultMessages(toolResults);
for (const auto &toolMsg : toolResultMessages) {
messages.append(toolMsg);
}
continuationRequest["messages"] = messages;
LOG_MESSAGE(QString("Sending continuation request for %1 with %2 tool results")
.arg(requestId)
.arg(toolResults.size()));
sendRequest(requestId, m_requestUrls[requestId], continuationRequest);
}
void OpenAICompatProvider::processStreamChunk(const QString &requestId, const QJsonObject &chunk)
{
QJsonArray choices = chunk["choices"].toArray();
if (choices.isEmpty()) {
return;
}
QJsonObject choice = choices[0].toObject();
QJsonObject delta = choice["delta"].toObject();
QString finishReason = choice["finish_reason"].toString();
OpenAIMessage *message = m_messages.value(requestId);
if (!message) {
message = new OpenAIMessage(this);
m_messages[requestId] = message;
LOG_MESSAGE(QString("Created NEW OpenAIMessage for request %1").arg(requestId));
if (m_dataBuffers.contains(requestId)) {
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Starting continuation for request %1").arg(requestId));
}
} else if (
m_dataBuffers.contains(requestId)
&& message->state() == LLMCore::MessageState::RequiresToolExecution) {
message->startNewContinuation();
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Cleared message state for continuation request %1").arg(requestId));
}
if (delta.contains("content") && !delta["content"].isNull()) {
QString content = delta["content"].toString();
message->handleContentDelta(content);
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
buffers.responseContent += content;
emit partialResponseReceived(requestId, content);
}
if (delta.contains("tool_calls")) {
QJsonArray toolCalls = delta["tool_calls"].toArray();
for (const auto &toolCallValue : toolCalls) {
QJsonObject toolCall = toolCallValue.toObject();
int index = toolCall["index"].toInt();
if (toolCall.contains("id")) {
QString id = toolCall["id"].toString();
QJsonObject function = toolCall["function"].toObject();
QString name = function["name"].toString();
message->handleToolCallStart(index, id, name);
}
if (toolCall.contains("function")) {
QJsonObject function = toolCall["function"].toObject();
if (function.contains("arguments")) {
QString args = function["arguments"].toString();
message->handleToolCallDelta(index, args);
}
}
}
}
if (!finishReason.isEmpty() && finishReason != "null") {
for (int i = 0; i < 10; ++i) {
message->handleToolCallComplete(i);
}
message->handleFinishReason(finishReason);
handleMessageComplete(requestId);
}
}
void OpenAICompatProvider::handleMessageComplete(const QString &requestId)
{
if (!m_messages.contains(requestId))
return;
OpenAIMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("OpenAICompat message requires tool execution for %1").arg(requestId));
auto toolUseContent = message->getCurrentToolUseContent();
if (toolUseContent.isEmpty()) {
LOG_MESSAGE(QString("No tools to execute for %1").arg(requestId));
return;
}
for (auto toolContent : toolUseContent) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(toolContent->name());
emit toolExecutionStarted(requestId, toolContent->id(), toolStringName);
m_toolsManager->executeToolCall(
requestId, toolContent->id(), toolContent->name(), toolContent->input());
}
} else {
LOG_MESSAGE(QString("OpenAICompat message marked as complete for %1").arg(requestId));
}
}
void OpenAICompatProvider::cleanupRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("Cleaning up OpenAICompat request %1").arg(requestId));
if (m_messages.contains(requestId)) {
OpenAIMessage *message = m_messages.take(requestId);
message->deleteLater();
}
m_dataBuffers.remove(requestId);
m_requestUrls.remove(requestId);
m_originalRequests.remove(requestId);
m_toolsManager->cleanupRequest(requestId);
return m_client;
}
} // namespace QodeAssist::Providers

48
providers/OpenAICompatProvider.hpp
View File

@@ -19,13 +19,12 @@
#pragma once
#include "OpenAIMessage.hpp"
#include "tools/ToolsManager.hpp"
#include <llmcore/Provider.hpp>
#include <LLMCore/OpenAIClient.hpp>
#include <pluginllmcore/Provider.hpp>
namespace QodeAssist::Providers {
class OpenAICompatProvider : public LLMCore::Provider
class OpenAICompatProvider : public PluginLLMCore::Provider
{
Q_OBJECT
public:
@@ -35,47 +34,22 @@ public:
QString url() const override;
QString completionEndpoint() const override;
QString chatEndpoint() const override;
bool supportsModelListing() const override;
void prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled) override;
QFuture<QList<QString>> getInstalledModels(const QString &url) override;
QList<QString> validateRequest(const QJsonObject &request, LLMCore::TemplateType type) override;
PluginLLMCore::ProviderID providerID() const override;
PluginLLMCore::ProviderCapabilities capabilities() const override;
::LLMCore::BaseClient *client() const override;
QString apiKey() const override;
void prepareNetworkRequest(QNetworkRequest &networkRequest) const override;
LLMCore::ProviderID providerID() const override;
void sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload) override;
bool supportsTools() const override;
bool supportImage() const override;
void cancelRequest(const LLMCore::RequestID &requestId) override;
public slots:
void onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data) override;
void onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId,
std::optional<QString> error) override;
private slots:
void onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults);
private:
void processStreamChunk(const QString &requestId, const QJsonObject &chunk);
void handleMessageComplete(const QString &requestId);
void cleanupRequest(const LLMCore::RequestID &requestId);
QHash<LLMCore::RequestID, OpenAIMessage *> m_messages;
QHash<LLMCore::RequestID, QUrl> m_requestUrls;
QHash<LLMCore::RequestID, QJsonObject> m_originalRequests;
Tools::ToolsManager *m_toolsManager;
::LLMCore::OpenAIClient *m_client;
};
} // namespace QodeAssist::Providers

34
providers/OpenAIMessage.cpp
View File

@@ -46,7 +46,7 @@ void OpenAIMessage::handleToolCallStart(int index, const QString &id, const QStr
m_currentBlocks.append(nullptr);
}
auto toolContent = new LLMCore::ToolUseContent(id, name);
auto toolContent = new PluginLLMCore::ToolUseContent(id, name);
toolContent->setParent(this);
m_currentBlocks[index] = toolContent;
m_pendingToolArguments[index] = "";
@@ -73,7 +73,7 @@ void OpenAIMessage::handleToolCallComplete(int index)
}
if (index < m_currentBlocks.size()) {
if (auto toolContent = qobject_cast<LLMCore::ToolUseContent *>(m_currentBlocks[index])) {
if (auto toolContent = qobject_cast<PluginLLMCore::ToolUseContent *>(m_currentBlocks[index])) {
toolContent->setInput(argsObject);
}
}
@@ -100,10 +100,10 @@ QJsonObject OpenAIMessage::toProviderFormat() const
if (!block)
continue;
if (auto text = qobject_cast<LLMCore::TextContent *>(block)) {
if (auto text = qobject_cast<PluginLLMCore::TextContent *>(block)) {
textContent += text->text();
} else if (auto tool = qobject_cast<LLMCore::ToolUseContent *>(block)) {
toolCalls.append(tool->toJson(LLMCore::ProviderFormat::OpenAI));
} else if (auto tool = qobject_cast<PluginLLMCore::ToolUseContent *>(block)) {
toolCalls.append(tool->toJson(PluginLLMCore::ProviderFormat::OpenAI));
}
}
@@ -126,20 +126,20 @@ QJsonArray OpenAIMessage::createToolResultMessages(const QHash<QString, QString>
for (auto toolContent : getCurrentToolUseContent()) {
if (toolResults.contains(toolContent->id())) {
auto toolResult = std::make_unique<LLMCore::ToolResultContent>(
auto toolResult = std::make_unique<PluginLLMCore::ToolResultContent>(
toolContent->id(), toolResults[toolContent->id()]);
messages.append(toolResult->toJson(LLMCore::ProviderFormat::OpenAI));
messages.append(toolResult->toJson(PluginLLMCore::ProviderFormat::OpenAI));
}
}
return messages;
}
QList<LLMCore::ToolUseContent *> OpenAIMessage::getCurrentToolUseContent() const
QList<PluginLLMCore::ToolUseContent *> OpenAIMessage::getCurrentToolUseContent() const
{
QList<LLMCore::ToolUseContent *> toolBlocks;
QList<PluginLLMCore::ToolUseContent *> toolBlocks;
for (auto block : m_currentBlocks) {
if (auto toolContent = qobject_cast<LLMCore::ToolUseContent *>(block)) {
if (auto toolContent = qobject_cast<PluginLLMCore::ToolUseContent *>(block)) {
toolBlocks.append(toolContent);
}
}
@@ -153,29 +153,29 @@ void OpenAIMessage::startNewContinuation()
m_currentBlocks.clear();
m_pendingToolArguments.clear();
m_finishReason.clear();
m_state = LLMCore::MessageState::Building;
m_state = PluginLLMCore::MessageState::Building;
}
void OpenAIMessage::updateStateFromFinishReason()
{
if (m_finishReason == "tool_calls" && !getCurrentToolUseContent().empty()) {
m_state = LLMCore::MessageState::RequiresToolExecution;
m_state = PluginLLMCore::MessageState::RequiresToolExecution;
} else if (m_finishReason == "stop") {
m_state = LLMCore::MessageState::Final;
m_state = PluginLLMCore::MessageState::Final;
} else {
m_state = LLMCore::MessageState::Complete;
m_state = PluginLLMCore::MessageState::Complete;
}
}
LLMCore::TextContent *OpenAIMessage::getOrCreateTextContent()
PluginLLMCore::TextContent *OpenAIMessage::getOrCreateTextContent()
{
for (auto block : m_currentBlocks) {
if (auto textContent = qobject_cast<LLMCore::TextContent *>(block)) {
if (auto textContent = qobject_cast<PluginLLMCore::TextContent *>(block)) {
return textContent;
}
}
return addCurrentContent<LLMCore::TextContent>();
return addCurrentContent<PluginLLMCore::TextContent>();
}
} // namespace QodeAssist::Providers

12
providers/OpenAIMessage.hpp
View File

@@ -19,7 +19,7 @@
#pragma once
#include <llmcore/ContentBlocks.hpp>
#include <pluginllmcore/ContentBlocks.hpp>
namespace QodeAssist::Providers {
@@ -38,19 +38,19 @@ public:
QJsonObject toProviderFormat() const;
QJsonArray createToolResultMessages(const QHash<QString, QString> &toolResults) const;
LLMCore::MessageState state() const { return m_state; }
QList<LLMCore::ToolUseContent *> getCurrentToolUseContent() const;
PluginLLMCore::MessageState state() const { return m_state; }
QList<PluginLLMCore::ToolUseContent *> getCurrentToolUseContent() const;
void startNewContinuation();
private:
QString m_finishReason;
LLMCore::MessageState m_state = LLMCore::MessageState::Building;
QList<LLMCore::ContentBlock *> m_currentBlocks;
PluginLLMCore::MessageState m_state = PluginLLMCore::MessageState::Building;
QList<PluginLLMCore::ContentBlock *> m_currentBlocks;
QHash<int, QString> m_pendingToolArguments;
void updateStateFromFinishReason();
LLMCore::TextContent *getOrCreateTextContent();
PluginLLMCore::TextContent *getOrCreateTextContent();
template<typename T, typename... Args>
T *addCurrentContent(Args &&...args)

352
providers/OpenAIProvider.cpp
View File

@@ -19,7 +19,8 @@
#include "OpenAIProvider.hpp"
#include "llmcore/ValidationUtils.hpp"
#include <LLMCore/ToolsManager.hpp>
#include "tools/ToolsRegistration.hpp"
#include "logger/Logger.hpp"
#include "settings/ChatAssistantSettings.hpp"
#include "settings/CodeCompletionSettings.hpp"
@@ -34,14 +35,10 @@
namespace QodeAssist::Providers {
OpenAIProvider::OpenAIProvider(QObject *parent)
: LLMCore::Provider(parent)
, m_toolsManager(new Tools::ToolsManager(this))
: PluginLLMCore::Provider(parent)
, m_client(new ::LLMCore::OpenAIClient(QString(), QString(), QString(), this))
{
connect(
m_toolsManager,
&Tools::ToolsManager::toolExecutionComplete,
this,
&OpenAIProvider::onToolExecutionComplete);
Tools::registerQodeAssistTools(m_client->tools());
}
QString OpenAIProvider::name() const
@@ -49,6 +46,11 @@ QString OpenAIProvider::name() const
return "OpenAI";
}
QString OpenAIProvider::apiKey() const
{
return Settings::providerSettings().openAiApiKey();
}
QString OpenAIProvider::url() const
{
return "https://api.openai.com";
@@ -64,16 +66,11 @@ QString OpenAIProvider::chatEndpoint() const
return "/v1/chat/completions";
}
bool OpenAIProvider::supportsModelListing() const
{
return true;
}
void OpenAIProvider::prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
{
@@ -116,22 +113,16 @@ void OpenAIProvider::prepareRequest(
request["presence_penalty"] = settings.presencePenalty();
};
if (type == LLMCore::RequestType::CodeCompletion) {
if (type == PluginLLMCore::RequestType::CodeCompletion) {
applyModelParams(Settings::codeCompletionSettings());
} else if (type == LLMCore::RequestType::QuickRefactoring) {
} else if (type == PluginLLMCore::RequestType::QuickRefactoring) {
applyModelParams(Settings::quickRefactorSettings());
} else {
applyModelParams(Settings::chatAssistantSettings());
}
if (isToolsEnabled) {
LLMCore::RunToolsFilter filter = LLMCore::RunToolsFilter::ALL;
if (type == LLMCore::RequestType::QuickRefactoring) {
filter = LLMCore::RunToolsFilter::OnlyRead;
}
auto toolsDefinitions = m_toolsManager->getToolsDefinitions(
LLMCore::ToolSchemaFormat::OpenAI, filter);
auto toolsDefinitions = m_client->tools()->getToolsDefinitions();
if (!toolsDefinitions.isEmpty()) {
request["tools"] = toolsDefinitions;
LOG_MESSAGE(QString("Added %1 tools to OpenAI request").arg(toolsDefinitions.size()));
@@ -139,318 +130,37 @@ void OpenAIProvider::prepareRequest(
}
}
QFuture<QList<QString>> OpenAIProvider::getInstalledModels(const QString &url)
QFuture<QList<QString>> OpenAIProvider::getInstalledModels(const QString &baseUrl)
{
QNetworkRequest request(QString("%1/v1/models").arg(url));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
if (!apiKey().isEmpty()) {
request.setRawHeader("Authorization", QString("Bearer %1").arg(apiKey()).toUtf8());
}
return httpClient()->get(request).then([](const QByteArray &data) {
QList<QString> models;
QJsonObject jsonObject = QJsonDocument::fromJson(data).object();
if (jsonObject.contains("data")) {
QJsonArray modelArray = jsonObject["data"].toArray();
for (const QJsonValue &value : modelArray) {
QJsonObject modelObject = value.toObject();
if (modelObject.contains("id")) {
QString modelId = modelObject["id"].toString();
m_client->setUrl(baseUrl);
m_client->setApiKey(apiKey());
return m_client->listModels().then([](const QList<QString> &allModels) {
QList<QString> filtered;
for (const QString &modelId : allModels) {
if (!modelId.contains("dall-e") && !modelId.contains("whisper")
&& !modelId.contains("tts") && !modelId.contains("davinci")
&& !modelId.contains("babbage") && !modelId.contains("omni")) {
models.append(modelId);
filtered.append(modelId);
}
}
}
}
return models;
}).onFailed([](const std::exception &e) {
LOG_MESSAGE(QString("Error fetching OpenAI models: %1").arg(e.what()));
return QList<QString>{};
return filtered;
});
}
QList<QString> OpenAIProvider::validateRequest(const QJsonObject &request, LLMCore::TemplateType type)
PluginLLMCore::ProviderID OpenAIProvider::providerID() const
{
const auto templateReq = QJsonObject{
{"model", {}},
{"messages", QJsonArray{{QJsonObject{{"role", {}}, {"content", {}}}}}},
{"temperature", {}},
{"max_tokens", {}},
{"max_completion_tokens", {}}, // New parameter for newer models
{"top_p", {}},
{"top_k", {}},
{"frequency_penalty", {}},
{"presence_penalty", {}},
{"stop", QJsonArray{}},
{"stream", {}},
{"tools", {}}};
return LLMCore::ValidationUtils::validateRequestFields(request, templateReq);
return PluginLLMCore::ProviderID::OpenAI;
}
QString OpenAIProvider::apiKey() const
PluginLLMCore::ProviderCapabilities OpenAIProvider::capabilities() const
{
return Settings::providerSettings().openAiApiKey();
return PluginLLMCore::ProviderCapability::Tools | PluginLLMCore::ProviderCapability::Image
| PluginLLMCore::ProviderCapability::ModelListing;
}
void OpenAIProvider::prepareNetworkRequest(QNetworkRequest &networkRequest) const
::LLMCore::BaseClient *OpenAIProvider::client() const
{
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
if (!apiKey().isEmpty()) {
networkRequest.setRawHeader("Authorization", QString("Bearer %1").arg(apiKey()).toUtf8());
}
}
LLMCore::ProviderID OpenAIProvider::providerID() const
{
return LLMCore::ProviderID::OpenAI;
}
void OpenAIProvider::sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload)
{
if (!m_messages.contains(requestId)) {
m_dataBuffers[requestId].clear();
}
m_requestUrls[requestId] = url;
m_originalRequests[requestId] = payload;
QNetworkRequest networkRequest(url);
prepareNetworkRequest(networkRequest);
LOG_MESSAGE(QString("OpenAIProvider: Sending request %1 to %2").arg(requestId, url.toString()));
httpClient()->postStreaming(requestId, networkRequest, payload);
}
bool OpenAIProvider::supportsTools() const
{
return true;
}
bool OpenAIProvider::supportImage() const
{
return true;
}
void OpenAIProvider::cancelRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("OpenAIProvider: Cancelling request %1").arg(requestId));
LLMCore::Provider::cancelRequest(requestId);
cleanupRequest(requestId);
}
void OpenAIProvider::onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data)
{
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
QStringList lines = buffers.rawStreamBuffer.processData(data);
for (const QString &line : lines) {
if (line.trimmed().isEmpty() || line == "data: [DONE]") {
continue;
}
QJsonObject chunk = parseEventLine(line);
if (chunk.isEmpty())
continue;
processStreamChunk(requestId, chunk);
}
}
void OpenAIProvider::onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId, std::optional<QString> error)
{
if (error) {
LOG_MESSAGE(QString("OpenAIProvider request %1 failed: %2").arg(requestId, *error));
emit requestFailed(requestId, *error);
cleanupRequest(requestId);
return;
}
if (m_messages.contains(requestId)) {
OpenAIMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("Waiting for tools to complete for %1").arg(requestId));
m_dataBuffers.remove(requestId);
return;
}
}
if (m_dataBuffers.contains(requestId)) {
const LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
if (!buffers.responseContent.isEmpty()) {
LOG_MESSAGE(QString("Emitting full response for %1").arg(requestId));
emit fullResponseReceived(requestId, buffers.responseContent);
}
}
cleanupRequest(requestId);
}
void OpenAIProvider::onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults)
{
if (!m_messages.contains(requestId) || !m_requestUrls.contains(requestId)) {
LOG_MESSAGE(QString("ERROR: Missing data for continuation request %1").arg(requestId));
cleanupRequest(requestId);
return;
}
LOG_MESSAGE(QString("Tool execution complete for OpenAI request %1").arg(requestId));
for (auto it = toolResults.begin(); it != toolResults.end(); ++it) {
OpenAIMessage *message = m_messages[requestId];
auto toolContent = message->getCurrentToolUseContent();
for (auto tool : toolContent) {
if (tool->id() == it.key()) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(tool->name());
emit toolExecutionCompleted(
requestId, tool->id(), toolStringName, toolResults[tool->id()]);
break;
}
}
}
OpenAIMessage *message = m_messages[requestId];
QJsonObject continuationRequest = m_originalRequests[requestId];
QJsonArray messages = continuationRequest["messages"].toArray();
messages.append(message->toProviderFormat());
QJsonArray toolResultMessages = message->createToolResultMessages(toolResults);
for (const auto &toolMsg : toolResultMessages) {
messages.append(toolMsg);
}
continuationRequest["messages"] = messages;
LOG_MESSAGE(QString("Sending continuation request for %1 with %2 tool results")
.arg(requestId)
.arg(toolResults.size()));
sendRequest(requestId, m_requestUrls[requestId], continuationRequest);
}
void OpenAIProvider::processStreamChunk(const QString &requestId, const QJsonObject &chunk)
{
QJsonArray choices = chunk["choices"].toArray();
if (choices.isEmpty()) {
return;
}
QJsonObject choice = choices[0].toObject();
QJsonObject delta = choice["delta"].toObject();
QString finishReason = choice["finish_reason"].toString();
OpenAIMessage *message = m_messages.value(requestId);
if (!message) {
message = new OpenAIMessage(this);
m_messages[requestId] = message;
LOG_MESSAGE(QString("Created NEW OpenAIAPIMessage for request %1").arg(requestId));
if (m_dataBuffers.contains(requestId)) {
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Starting continuation for request %1").arg(requestId));
}
} else if (
m_dataBuffers.contains(requestId)
&& message->state() == LLMCore::MessageState::RequiresToolExecution) {
message->startNewContinuation();
emit continuationStarted(requestId);
LOG_MESSAGE(QString("Cleared message state for continuation request %1").arg(requestId));
}
if (delta.contains("content") && !delta["content"].isNull()) {
QString content = delta["content"].toString();
message->handleContentDelta(content);
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
buffers.responseContent += content;
emit partialResponseReceived(requestId, content);
}
if (delta.contains("tool_calls")) {
QJsonArray toolCalls = delta["tool_calls"].toArray();
for (const auto &toolCallValue : toolCalls) {
QJsonObject toolCall = toolCallValue.toObject();
int index = toolCall["index"].toInt();
if (toolCall.contains("id")) {
QString id = toolCall["id"].toString();
QJsonObject function = toolCall["function"].toObject();
QString name = function["name"].toString();
message->handleToolCallStart(index, id, name);
}
if (toolCall.contains("function")) {
QJsonObject function = toolCall["function"].toObject();
if (function.contains("arguments")) {
QString args = function["arguments"].toString();
message->handleToolCallDelta(index, args);
}
}
}
}
if (!finishReason.isEmpty() && finishReason != "null") {
for (int i = 0; i < 10; ++i) {
message->handleToolCallComplete(i);
}
message->handleFinishReason(finishReason);
handleMessageComplete(requestId);
}
}
void OpenAIProvider::handleMessageComplete(const QString &requestId)
{
if (!m_messages.contains(requestId))
return;
OpenAIMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
LOG_MESSAGE(QString("OpenAI message requires tool execution for %1").arg(requestId));
auto toolUseContent = message->getCurrentToolUseContent();
if (toolUseContent.isEmpty()) {
LOG_MESSAGE(QString("No tools to execute for %1").arg(requestId));
return;
}
for (auto toolContent : toolUseContent) {
auto toolStringName = m_toolsManager->toolsFactory()->getStringName(toolContent->name());
emit toolExecutionStarted(requestId, toolContent->id(), toolStringName);
m_toolsManager->executeToolCall(
requestId, toolContent->id(), toolContent->name(), toolContent->input());
}
} else {
LOG_MESSAGE(QString("OpenAI message marked as complete for %1").arg(requestId));
}
}
void OpenAIProvider::cleanupRequest(const LLMCore::RequestID &requestId)
{
LOG_MESSAGE(QString("Cleaning up OpenAI request %1").arg(requestId));
if (m_messages.contains(requestId)) {
OpenAIMessage *message = m_messages.take(requestId);
message->deleteLater();
}
m_dataBuffers.remove(requestId);
m_requestUrls.remove(requestId);
m_originalRequests.remove(requestId);
m_toolsManager->cleanupRequest(requestId);
return m_client;
}
} // namespace QodeAssist::Providers

48
providers/OpenAIProvider.hpp
View File

@@ -19,13 +19,12 @@
#pragma once
#include "OpenAIMessage.hpp"
#include "tools/ToolsManager.hpp"
#include <llmcore/Provider.hpp>
#include <LLMCore/OpenAIClient.hpp>
#include <pluginllmcore/Provider.hpp>
namespace QodeAssist::Providers {
class OpenAIProvider : public LLMCore::Provider
class OpenAIProvider : public PluginLLMCore::Provider
{
Q_OBJECT
public:
@@ -35,47 +34,22 @@ public:
QString url() const override;
QString completionEndpoint() const override;
QString chatEndpoint() const override;
bool supportsModelListing() const override;
void prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled) override;
QFuture<QList<QString>> getInstalledModels(const QString &url) override;
QList<QString> validateRequest(const QJsonObject &request, LLMCore::TemplateType type) override;
PluginLLMCore::ProviderID providerID() const override;
PluginLLMCore::ProviderCapabilities capabilities() const override;
::LLMCore::BaseClient *client() const override;
QString apiKey() const override;
void prepareNetworkRequest(QNetworkRequest &networkRequest) const override;
LLMCore::ProviderID providerID() const override;
void sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload) override;
bool supportsTools() const override;
bool supportImage() const override;
void cancelRequest(const LLMCore::RequestID &requestId) override;
public slots:
void onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data) override;
void onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId,
std::optional<QString> error) override;
private slots:
void onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults);
private:
void processStreamChunk(const QString &requestId, const QJsonObject &chunk);
void handleMessageComplete(const QString &requestId);
void cleanupRequest(const LLMCore::RequestID &requestId);
QHash<LLMCore::RequestID, OpenAIMessage *> m_messages;
QHash<LLMCore::RequestID, QUrl> m_requestUrls;
QHash<LLMCore::RequestID, QJsonObject> m_originalRequests;
Tools::ToolsManager *m_toolsManager;
::LLMCore::OpenAIClient *m_client;
};
} // namespace QodeAssist::Providers

44
providers/OpenAIResponsesMessage.cpp
View File

@@ -52,7 +52,7 @@ void OpenAIResponsesMessage::handleItemDelta(const QJsonObject &item)
void OpenAIResponsesMessage::handleToolCallStart(const QString &callId, const QString &name)
{
auto toolContent = new LLMCore::ToolUseContent(callId, name);
auto toolContent = new PluginLLMCore::ToolUseContent(callId, name);
toolContent->setParent(this);
m_items.append(toolContent);
m_toolCalls[callId] = toolContent;
@@ -86,7 +86,7 @@ void OpenAIResponsesMessage::handleToolCallComplete(const QString &callId)
void OpenAIResponsesMessage::handleReasoningStart(const QString &itemId)
{
auto thinkingContent = new LLMCore::ThinkingContent();
auto thinkingContent = new PluginLLMCore::ThinkingContent();
thinkingContent->setParent(this);
m_items.append(thinkingContent);
m_thinkingBlocks[itemId] = thinkingContent;
@@ -115,13 +115,13 @@ QList<QJsonObject> OpenAIResponsesMessage::toItemsFormat() const
QList<QJsonObject> items;
QString textContent;
QList<LLMCore::ToolUseContent *> toolCalls;
QList<PluginLLMCore::ToolUseContent *> toolCalls;
for (const auto *block : m_items) {
if (const auto *text = qobject_cast<const LLMCore::TextContent *>(block)) {
if (const auto *text = qobject_cast<const PluginLLMCore::TextContent *>(block)) {
textContent += text->text();
} else if (auto *tool = qobject_cast<LLMCore::ToolUseContent *>(
const_cast<LLMCore::ContentBlock *>(block))) {
} else if (auto *tool = qobject_cast<PluginLLMCore::ToolUseContent *>(
const_cast<PluginLLMCore::ContentBlock *>(block))) {
toolCalls.append(tool);
}
}
@@ -146,22 +146,22 @@ QList<QJsonObject> OpenAIResponsesMessage::toItemsFormat() const
return items;
}
QList<LLMCore::ToolUseContent *> OpenAIResponsesMessage::getCurrentToolUseContent() const
QList<PluginLLMCore::ToolUseContent *> OpenAIResponsesMessage::getCurrentToolUseContent() const
{
QList<LLMCore::ToolUseContent *> toolBlocks;
QList<PluginLLMCore::ToolUseContent *> toolBlocks;
for (auto *block : m_items) {
if (auto *toolContent = qobject_cast<LLMCore::ToolUseContent *>(block)) {
if (auto *toolContent = qobject_cast<PluginLLMCore::ToolUseContent *>(block)) {
toolBlocks.append(toolContent);
}
}
return toolBlocks;
}
QList<LLMCore::ThinkingContent *> OpenAIResponsesMessage::getCurrentThinkingContent() const
QList<PluginLLMCore::ThinkingContent *> OpenAIResponsesMessage::getCurrentThinkingContent() const
{
QList<LLMCore::ThinkingContent *> thinkingBlocks;
QList<PluginLLMCore::ThinkingContent *> thinkingBlocks;
for (auto *block : m_items) {
if (auto *thinkingContent = qobject_cast<LLMCore::ThinkingContent *>(block)) {
if (auto *thinkingContent = qobject_cast<PluginLLMCore::ThinkingContent *>(block)) {
thinkingBlocks.append(thinkingContent);
}
}
@@ -189,7 +189,7 @@ QString OpenAIResponsesMessage::accumulatedText() const
{
QString text;
for (const auto *block : m_items) {
if (const auto *textContent = qobject_cast<const LLMCore::TextContent *>(block)) {
if (const auto *textContent = qobject_cast<const PluginLLMCore::TextContent *>(block)) {
text += textContent->text();
}
}
@@ -202,28 +202,28 @@ void OpenAIResponsesMessage::updateStateFromStatus()
if (m_status == "completed") {
if (!getCurrentToolUseContent().isEmpty()) {
m_state = LLMCore::MessageState::RequiresToolExecution;
m_state = PluginLLMCore::MessageState::RequiresToolExecution;
} else {
m_state = LLMCore::MessageState::Complete;
m_state = PluginLLMCore::MessageState::Complete;
}
} else if (m_status == "in_progress") {
m_state = LLMCore::MessageState::Building;
m_state = PluginLLMCore::MessageState::Building;
} else if (m_status == "failed" || m_status == "cancelled" || m_status == "incomplete") {
m_state = LLMCore::MessageState::Final;
m_state = PluginLLMCore::MessageState::Final;
} else {
m_state = LLMCore::MessageState::Building;
m_state = PluginLLMCore::MessageState::Building;
}
}
LLMCore::TextContent *OpenAIResponsesMessage::getOrCreateTextItem()
PluginLLMCore::TextContent *OpenAIResponsesMessage::getOrCreateTextItem()
{
for (auto *block : m_items) {
if (auto *textContent = qobject_cast<LLMCore::TextContent *>(block)) {
if (auto *textContent = qobject_cast<PluginLLMCore::TextContent *>(block)) {
return textContent;
}
}
auto *textContent = new LLMCore::TextContent();
auto *textContent = new PluginLLMCore::TextContent();
textContent->setParent(this);
m_items.append(textContent);
return textContent;
@@ -239,7 +239,7 @@ void OpenAIResponsesMessage::startNewContinuation()
m_pendingToolArguments.clear();
m_status.clear();
m_state = LLMCore::MessageState::Building;
m_state = PluginLLMCore::MessageState::Building;
}
} // namespace QodeAssist::Providers

18
providers/OpenAIResponsesMessage.hpp
View File

@@ -19,7 +19,7 @@
#pragma once
#include <llmcore/ContentBlocks.hpp>
#include <pluginllmcore/ContentBlocks.hpp>
namespace QodeAssist::Providers {
@@ -41,10 +41,10 @@ public:
QList<QJsonObject> toItemsFormat() const;
QJsonArray createToolResultItems(const QHash<QString, QString> &toolResults) const;
LLMCore::MessageState state() const noexcept { return m_state; }
PluginLLMCore::MessageState state() const noexcept { return m_state; }
QString accumulatedText() const;
QList<LLMCore::ToolUseContent *> getCurrentToolUseContent() const;
QList<LLMCore::ThinkingContent *> getCurrentThinkingContent() const;
QList<PluginLLMCore::ToolUseContent *> getCurrentToolUseContent() const;
QList<PluginLLMCore::ThinkingContent *> getCurrentThinkingContent() const;
bool hasToolCalls() const noexcept { return !m_toolCalls.isEmpty(); }
bool hasThinkingContent() const noexcept { return !m_thinkingBlocks.isEmpty(); }
@@ -53,14 +53,14 @@ public:
private:
QString m_status;
LLMCore::MessageState m_state = LLMCore::MessageState::Building;
QList<LLMCore::ContentBlock *> m_items;
PluginLLMCore::MessageState m_state = PluginLLMCore::MessageState::Building;
QList<PluginLLMCore::ContentBlock *> m_items;
QHash<QString, QString> m_pendingToolArguments;
QHash<QString, LLMCore::ToolUseContent *> m_toolCalls;
QHash<QString, LLMCore::ThinkingContent *> m_thinkingBlocks;
QHash<QString, PluginLLMCore::ToolUseContent *> m_toolCalls;
QHash<QString, PluginLLMCore::ThinkingContent *> m_thinkingBlocks;
void updateStateFromStatus();
LLMCore::TextContent *getOrCreateTextItem();
PluginLLMCore::TextContent *getOrCreateTextItem();
};
} // namespace QodeAssist::Providers

528
providers/OpenAIResponsesProvider.cpp
View File

@@ -18,9 +18,9 @@
*/
#include "OpenAIResponsesProvider.hpp"
#include "OpenAIResponses/ResponseObject.hpp"
#include <LLMCore/ToolsManager.hpp>
#include "tools/ToolsRegistration.hpp"
#include "llmcore/ValidationUtils.hpp"
#include "logger/Logger.hpp"
#include "settings/ChatAssistantSettings.hpp"
#include "settings/CodeCompletionSettings.hpp"
@@ -35,14 +35,10 @@
namespace QodeAssist::Providers {
OpenAIResponsesProvider::OpenAIResponsesProvider(QObject *parent)
: LLMCore::Provider(parent)
, m_toolsManager(new Tools::ToolsManager(this))
: PluginLLMCore::Provider(parent)
, m_client(new ::LLMCore::OpenAIResponsesClient(QString(), QString(), QString(), this))
{
connect(
m_toolsManager,
&Tools::ToolsManager::toolExecutionComplete,
this,
&OpenAIResponsesProvider::onToolExecutionComplete);
Tools::registerQodeAssistTools(m_client->tools());
}
QString OpenAIResponsesProvider::name() const
@@ -50,6 +46,11 @@ QString OpenAIResponsesProvider::name() const
return "OpenAI Responses";
}
QString OpenAIResponsesProvider::apiKey() const
{
return Settings::providerSettings().openAiApiKey();
}
QString OpenAIResponsesProvider::url() const
{
return "https://api.openai.com";
@@ -65,16 +66,11 @@ QString OpenAIResponsesProvider::chatEndpoint() const
return "/v1/responses";
}
bool OpenAIResponsesProvider::supportsModelListing() const
{
return true;
}
void OpenAIResponsesProvider::prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled)
{
@@ -109,9 +105,9 @@ void OpenAIResponsesProvider::prepareRequest(
request["include"] = include;
};
if (type == LLMCore::RequestType::CodeCompletion) {
if (type == PluginLLMCore::RequestType::CodeCompletion) {
applyModelParams(Settings::codeCompletionSettings());
} else if (type == LLMCore::RequestType::QuickRefactoring) {
} else if (type == PluginLLMCore::RequestType::QuickRefactoring) {
const auto &qrSettings = Settings::quickRefactorSettings();
applyModelParams(qrSettings);
@@ -128,12 +124,8 @@ void OpenAIResponsesProvider::prepareRequest(
}
if (isToolsEnabled) {
const LLMCore::RunToolsFilter filter = (type == LLMCore::RequestType::QuickRefactoring)
? LLMCore::RunToolsFilter::OnlyRead
: LLMCore::RunToolsFilter::ALL;
const auto toolsDefinitions
= m_toolsManager->getToolsDefinitions(LLMCore::ToolSchemaFormat::OpenAI, filter);
= m_client->tools()->getToolsDefinitions();
if (!toolsDefinitions.isEmpty()) {
QJsonArray responsesTools;
@@ -156,496 +148,40 @@ void OpenAIResponsesProvider::prepareRequest(
request["stream"] = true;
}
QFuture<QList<QString>> OpenAIResponsesProvider::getInstalledModels(const QString &url)
QFuture<QList<QString>> OpenAIResponsesProvider::getInstalledModels(const QString &baseUrl)
{
QNetworkRequest request(QString("%1/v1/models").arg(url));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
if (!apiKey().isEmpty()) {
request.setRawHeader("Authorization", QString("Bearer %1").arg(apiKey()).toUtf8());
}
return httpClient()->get(request).then([](const QByteArray &data) {
QList<QString> models;
const QJsonObject jsonObject = QJsonDocument::fromJson(data).object();
if (jsonObject.contains("data")) {
const QJsonArray modelArray = jsonObject["data"].toArray();
models.reserve(modelArray.size());
m_client->setUrl(baseUrl);
m_client->setApiKey(apiKey());
return m_client->listModels().then([](const QList<QString> &models) {
QList<QString> filtered;
static const QStringList modelPrefixes = {"gpt-5", "o1", "o2", "o3", "o4"};
for (const QJsonValue &value : modelArray) {
const QJsonObject modelObject = value.toObject();
if (!modelObject.contains("id")) {
continue;
}
const QString modelId = modelObject["id"].toString();
for (const QString &modelId : models) {
for (const QString &prefix : modelPrefixes) {
if (modelId.contains(prefix)) {
models.append(modelId);
filtered.append(modelId);
break;
}
}
}
}
return models;
}).onFailed([](const std::exception &e) {
LOG_MESSAGE(QString("Error fetching OpenAI models: %1").arg(e.what()));
return QList<QString>{};
return filtered;
});
}
QList<QString> OpenAIResponsesProvider::validateRequest(
const QJsonObject &request, LLMCore::TemplateType type)
PluginLLMCore::ProviderID OpenAIResponsesProvider::providerID() const
{
Q_UNUSED(type);
QList<QString> errors;
if (!request.contains("input")) {
errors.append("Missing required field: input");
return errors;
return PluginLLMCore::ProviderID::OpenAIResponses;
}
const QJsonValue inputValue = request["input"];
if (!inputValue.isString() && !inputValue.isArray()) {
errors.append("Field 'input' must be either a string or an array");
}
if (request.contains("max_output_tokens") && !request["max_output_tokens"].isDouble()) {
errors.append("Field 'max_output_tokens' must be a number");
}
if (request.contains("top_p") && !request["top_p"].isDouble()) {
errors.append("Field 'top_p' must be a number");
}
if (request.contains("reasoning") && !request["reasoning"].isObject()) {
errors.append("Field 'reasoning' must be an object");
}
if (request.contains("stream") && !request["stream"].isBool()) {
errors.append("Field 'stream' must be a boolean");
}
if (request.contains("tools") && !request["tools"].isArray()) {
errors.append("Field 'tools' must be an array");
}
return errors;
}
QString OpenAIResponsesProvider::apiKey() const
PluginLLMCore::ProviderCapabilities OpenAIResponsesProvider::capabilities() const
{
return Settings::providerSettings().openAiApiKey();
return PluginLLMCore::ProviderCapability::Tools | PluginLLMCore::ProviderCapability::Thinking
| PluginLLMCore::ProviderCapability::Image
| PluginLLMCore::ProviderCapability::ModelListing;
}
void OpenAIResponsesProvider::prepareNetworkRequest(QNetworkRequest &networkRequest) const
::LLMCore::BaseClient *OpenAIResponsesProvider::client() const
{
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
if (!apiKey().isEmpty()) {
networkRequest.setRawHeader("Authorization", QString("Bearer %1").arg(apiKey()).toUtf8());
}
}
LLMCore::ProviderID OpenAIResponsesProvider::providerID() const
{
return LLMCore::ProviderID::OpenAIResponses;
}
void OpenAIResponsesProvider::sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload)
{
if (!m_messages.contains(requestId)) {
m_dataBuffers[requestId].clear();
}
m_requestUrls[requestId] = url;
m_originalRequests[requestId] = payload;
QNetworkRequest networkRequest(url);
prepareNetworkRequest(networkRequest);
httpClient()->postStreaming(requestId, networkRequest, payload);
}
bool OpenAIResponsesProvider::supportsTools() const
{
return true;
}
bool OpenAIResponsesProvider::supportImage() const
{
return true;
}
bool OpenAIResponsesProvider::supportThinking() const
{
return true;
}
void OpenAIResponsesProvider::cancelRequest(const LLMCore::RequestID &requestId)
{
LLMCore::Provider::cancelRequest(requestId);
cleanupRequest(requestId);
}
void OpenAIResponsesProvider::onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data)
{
LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
const QStringList lines = buffers.rawStreamBuffer.processData(data);
QString currentEventType;
for (const QString &line : lines) {
const QString trimmedLine = line.trimmed();
if (trimmedLine.isEmpty()) {
continue;
}
if (line == "data: [DONE]") {
continue;
}
if (line.startsWith("event: ")) {
currentEventType = line.mid(7).trimmed();
continue;
}
QString dataLine = line;
if (line.startsWith("data: ")) {
dataLine = line.mid(6);
}
const QJsonDocument doc = QJsonDocument::fromJson(dataLine.toUtf8());
if (doc.isObject()) {
const QJsonObject obj = doc.object();
processStreamEvent(requestId, currentEventType, obj);
}
}
}
void OpenAIResponsesProvider::onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId, std::optional<QString> error)
{
if (error) {
LOG_MESSAGE(QString("OpenAIResponses request %1 failed: %2").arg(requestId, *error));
emit requestFailed(requestId, *error);
cleanupRequest(requestId);
return;
}
if (m_messages.contains(requestId)) {
OpenAIResponsesMessage *message = m_messages[requestId];
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
return;
}
}
if (m_dataBuffers.contains(requestId)) {
const LLMCore::DataBuffers &buffers = m_dataBuffers[requestId];
if (!buffers.responseContent.isEmpty()) {
emit fullResponseReceived(requestId, buffers.responseContent);
} else {
LOG_MESSAGE(QString("WARNING: OpenAIResponses - Response content is empty for %1, "
"emitting empty response")
.arg(requestId));
emit fullResponseReceived(requestId, "");
}
} else {
LOG_MESSAGE(
QString("WARNING: OpenAIResponses - No data buffer found for %1").arg(requestId));
}
cleanupRequest(requestId);
}
void OpenAIResponsesProvider::processStreamEvent(
const QString &requestId, const QString &eventType, const QJsonObject &data)
{
OpenAIResponsesMessage *message = m_messages.value(requestId);
if (!message) {
message = new OpenAIResponsesMessage(this);
m_messages[requestId] = message;
if (m_dataBuffers.contains(requestId)) {
emit continuationStarted(requestId);
}
} else if (
m_dataBuffers.contains(requestId)
&& message->state() == LLMCore::MessageState::RequiresToolExecution) {
message->startNewContinuation();
emit continuationStarted(requestId);
}
if (eventType == "response.content_part.added") {
} else if (eventType == "response.output_text.delta") {
const QString delta = data["delta"].toString();
if (!delta.isEmpty()) {
m_dataBuffers[requestId].responseContent += delta;
emit partialResponseReceived(requestId, delta);
}
} else if (eventType == "response.output_text.done") {
const QString fullText = data["text"].toString();
if (!fullText.isEmpty()) {
m_dataBuffers[requestId].responseContent = fullText;
}
} else if (eventType == "response.content_part.done") {
} else if (eventType == "response.output_item.added") {
using namespace QodeAssist::OpenAIResponses;
const QJsonObject item = data["item"].toObject();
OutputItem outputItem = OutputItem::fromJson(item);
if (const auto *functionCall = outputItem.asFunctionCall()) {
if (!functionCall->callId.isEmpty() && !functionCall->name.isEmpty()) {
if (!m_itemIdToCallId.contains(requestId)) {
m_itemIdToCallId[requestId] = QHash<QString, QString>();
}
m_itemIdToCallId[requestId][functionCall->id] = functionCall->callId;
message->handleToolCallStart(functionCall->callId, functionCall->name);
}
} else if (const auto *reasoning = outputItem.asReasoning()) {
if (!reasoning->id.isEmpty()) {
message->handleReasoningStart(reasoning->id);
}
}
} else if (eventType == "response.reasoning_content.delta") {
const QString itemId = data["item_id"].toString();
const QString delta = data["delta"].toString();
if (!itemId.isEmpty() && !delta.isEmpty()) {
message->handleReasoningDelta(itemId, delta);
}
} else if (eventType == "response.reasoning_content.done") {
const QString itemId = data["item_id"].toString();
if (!itemId.isEmpty()) {
message->handleReasoningComplete(itemId);
emitPendingThinkingBlocks(requestId);
}
} else if (eventType == "response.function_call_arguments.delta") {
const QString itemId = data["item_id"].toString();
const QString delta = data["delta"].toString();
if (!itemId.isEmpty() && !delta.isEmpty()) {
const QString callId = m_itemIdToCallId.value(requestId).value(itemId);
if (!callId.isEmpty()) {
message->handleToolCallDelta(callId, delta);
} else {
LOG_MESSAGE(QString("ERROR: No call_id mapping found for item_id: %1").arg(itemId));
}
}
} else if (
eventType == "response.function_call_arguments.done"
|| eventType == "response.output_item.done") {
const QString itemId = data["item_id"].toString();
const QJsonObject item = data["item"].toObject();
if (!item.isEmpty() && item["type"].toString() == "reasoning") {
using namespace QodeAssist::OpenAIResponses;
const QString finalItemId = itemId.isEmpty() ? item["id"].toString() : itemId;
ReasoningOutput reasoningOutput = ReasoningOutput::fromJson(item);
QString reasoningText;
if (!reasoningOutput.summaryText.isEmpty()) {
reasoningText = reasoningOutput.summaryText;
} else if (!reasoningOutput.contentTexts.isEmpty()) {
reasoningText = reasoningOutput.contentTexts.join("\n");
}
if (reasoningText.isEmpty()) {
reasoningText = QString(
"[Reasoning process completed, but detailed thinking is not available in "
"streaming mode. The model has processed your request with extended reasoning.]");
}
if (!finalItemId.isEmpty()) {
message->handleReasoningDelta(finalItemId, reasoningText);
message->handleReasoningComplete(finalItemId);
emitPendingThinkingBlocks(requestId);
}
} else if (item.isEmpty() && !itemId.isEmpty()) {
const QString callId = m_itemIdToCallId.value(requestId).value(itemId);
if (!callId.isEmpty()) {
message->handleToolCallComplete(callId);
} else {
LOG_MESSAGE(
QString("ERROR: OpenAIResponses - No call_id mapping found for item_id: %1")
.arg(itemId));
}
} else if (!item.isEmpty() && item["type"].toString() == "function_call") {
const QString callId = item["call_id"].toString();
if (!callId.isEmpty()) {
message->handleToolCallComplete(callId);
} else {
LOG_MESSAGE(
QString("ERROR: OpenAIResponses - Function call done but call_id is empty"));
}
}
} else if (eventType == "response.created") {
} else if (eventType == "response.in_progress") {
} else if (eventType == "response.completed") {
using namespace QodeAssist::OpenAIResponses;
const QJsonObject responseObj = data["response"].toObject();
Response response = Response::fromJson(responseObj);
const QString statusStr = responseObj["status"].toString();
if (m_dataBuffers[requestId].responseContent.isEmpty()) {
const QString aggregatedText = response.getAggregatedText();
if (!aggregatedText.isEmpty()) {
m_dataBuffers[requestId].responseContent = aggregatedText;
}
}
message->handleStatus(statusStr);
handleMessageComplete(requestId);
} else if (eventType == "response.incomplete") {
using namespace QodeAssist::OpenAIResponses;
const QJsonObject responseObj = data["response"].toObject();
if (!responseObj.isEmpty()) {
Response response = Response::fromJson(responseObj);
const QString statusStr = responseObj["status"].toString();
if (m_dataBuffers[requestId].responseContent.isEmpty()) {
const QString aggregatedText = response.getAggregatedText();
if (!aggregatedText.isEmpty()) {
m_dataBuffers[requestId].responseContent = aggregatedText;
}
}
message->handleStatus(statusStr);
} else {
message->handleStatus("incomplete");
}
handleMessageComplete(requestId);
} else if (!eventType.isEmpty()) {
LOG_MESSAGE(QString("WARNING: OpenAIResponses - Unhandled event type '%1' for request %2\nData: %3")
.arg(eventType)
.arg(requestId)
.arg(QString::fromUtf8(QJsonDocument(data).toJson(QJsonDocument::Compact))));
}
}
void OpenAIResponsesProvider::emitPendingThinkingBlocks(const QString &requestId)
{
if (!m_messages.contains(requestId)) {
return;
}
OpenAIResponsesMessage *message = m_messages[requestId];
const auto thinkingBlocks = message->getCurrentThinkingContent();
if (thinkingBlocks.isEmpty()) {
return;
}
const int alreadyEmitted = m_emittedThinkingBlocksCount.value(requestId, 0);
const int totalBlocks = thinkingBlocks.size();
for (int i = alreadyEmitted; i < totalBlocks; ++i) {
const auto *thinkingContent = thinkingBlocks[i];
if (thinkingContent->thinking().trimmed().isEmpty()) {
continue;
}
emit thinkingBlockReceived(
requestId, thinkingContent->thinking(), thinkingContent->signature());
}
m_emittedThinkingBlocksCount[requestId] = totalBlocks;
}
void OpenAIResponsesProvider::handleMessageComplete(const QString &requestId)
{
if (!m_messages.contains(requestId)) {
return;
}
OpenAIResponsesMessage *message = m_messages[requestId];
emitPendingThinkingBlocks(requestId);
if (message->state() == LLMCore::MessageState::RequiresToolExecution) {
const auto toolUseContent = message->getCurrentToolUseContent();
if (toolUseContent.isEmpty()) {
return;
}
for (const auto *toolContent : toolUseContent) {
const auto toolStringName = m_toolsManager->toolsFactory()->getStringName(
toolContent->name());
emit toolExecutionStarted(requestId, toolContent->id(), toolStringName);
m_toolsManager->executeToolCall(
requestId, toolContent->id(), toolContent->name(), toolContent->input());
}
}
}
void OpenAIResponsesProvider::onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults)
{
if (!m_messages.contains(requestId) || !m_requestUrls.contains(requestId)) {
LOG_MESSAGE(QString("ERROR: OpenAIResponses - Missing data for continuation request %1")
.arg(requestId));
cleanupRequest(requestId);
return;
}
OpenAIResponsesMessage *message = m_messages[requestId];
const auto toolContent = message->getCurrentToolUseContent();
for (auto it = toolResults.constBegin(); it != toolResults.constEnd(); ++it) {
for (const auto *tool : toolContent) {
if (tool->id() == it.key()) {
const auto toolStringName = m_toolsManager->toolsFactory()->getStringName(
tool->name());
emit toolExecutionCompleted(
requestId, tool->id(), toolStringName, toolResults[tool->id()]);
break;
}
}
}
QJsonObject continuationRequest = m_originalRequests[requestId];
QJsonArray input = continuationRequest["input"].toArray();
const QList<QJsonObject> assistantItems = message->toItemsFormat();
for (const QJsonObject &item : assistantItems) {
input.append(item);
}
const QJsonArray toolResultItems = message->createToolResultItems(toolResults);
for (const QJsonValue &item : toolResultItems) {
input.append(item);
}
continuationRequest["input"] = input;
m_dataBuffers[requestId].responseContent.clear();
sendRequest(requestId, m_requestUrls[requestId], continuationRequest);
}
void OpenAIResponsesProvider::cleanupRequest(const LLMCore::RequestID &requestId)
{
if (m_messages.contains(requestId)) {
OpenAIResponsesMessage *message = m_messages.take(requestId);
message->deleteLater();
}
m_dataBuffers.remove(requestId);
m_requestUrls.remove(requestId);
m_originalRequests.remove(requestId);
m_itemIdToCallId.remove(requestId);
m_emittedThinkingBlocksCount.remove(requestId);
m_toolsManager->cleanupRequest(requestId);
return m_client;
}
} // namespace QodeAssist::Providers

53
providers/OpenAIResponsesProvider.hpp
View File

@@ -19,13 +19,12 @@
#pragma once
#include "OpenAIResponsesMessage.hpp"
#include "tools/ToolsManager.hpp"
#include <llmcore/Provider.hpp>
#include <LLMCore/OpenAIResponsesClient.hpp>
#include <pluginllmcore/Provider.hpp>
namespace QodeAssist::Providers {
class OpenAIResponsesProvider : public LLMCore::Provider
class OpenAIResponsesProvider : public PluginLLMCore::Provider
{
Q_OBJECT
public:
@@ -35,52 +34,22 @@ public:
QString url() const override;
QString completionEndpoint() const override;
QString chatEndpoint() const override;
bool supportsModelListing() const override;
void prepareRequest(
QJsonObject &request,
LLMCore::PromptTemplate *prompt,
LLMCore::ContextData context,
LLMCore::RequestType type,
PluginLLMCore::PromptTemplate *prompt,
PluginLLMCore::ContextData context,
PluginLLMCore::RequestType type,
bool isToolsEnabled,
bool isThinkingEnabled) override;
QFuture<QList<QString>> getInstalledModels(const QString &url) override;
QList<QString> validateRequest(const QJsonObject &request, LLMCore::TemplateType type) override;
PluginLLMCore::ProviderID providerID() const override;
PluginLLMCore::ProviderCapabilities capabilities() const override;
::LLMCore::BaseClient *client() const override;
QString apiKey() const override;
void prepareNetworkRequest(QNetworkRequest &networkRequest) const override;
LLMCore::ProviderID providerID() const override;
void sendRequest(
const LLMCore::RequestID &requestId, const QUrl &url, const QJsonObject &payload) override;
bool supportsTools() const override;
bool supportImage() const override;
bool supportThinking() const override;
void cancelRequest(const LLMCore::RequestID &requestId) override;
public slots:
void onDataReceived(
const QodeAssist::LLMCore::RequestID &requestId, const QByteArray &data) override;
void onRequestFinished(
const QodeAssist::LLMCore::RequestID &requestId,
std::optional<QString> error) override;
private slots:
void onToolExecutionComplete(
const QString &requestId, const QHash<QString, QString> &toolResults);
private:
void processStreamEvent(const QString &requestId, const QString &eventType, const QJsonObject &data);
void emitPendingThinkingBlocks(const QString &requestId);
void handleMessageComplete(const QString &requestId);
void cleanupRequest(const LLMCore::RequestID &requestId);
QHash<LLMCore::RequestID, OpenAIResponsesMessage *> m_messages;
QHash<LLMCore::RequestID, QUrl> m_requestUrls;
QHash<LLMCore::RequestID, QJsonObject> m_originalRequests;
QHash<LLMCore::RequestID, QHash<QString, QString>> m_itemIdToCallId;
QHash<LLMCore::RequestID, int> m_emittedThinkingBlocksCount;
Tools::ToolsManager *m_toolsManager;
::LLMCore::OpenAIResponsesClient *m_client;
};
} // namespace QodeAssist::Providers

18
providers/OpenRouterAIProvider.cpp
View File

@@ -28,24 +28,28 @@
namespace QodeAssist::Providers {
OpenRouterProvider::OpenRouterProvider(QObject *parent)
: OpenAICompatProvider(parent)
{}
QString OpenRouterProvider::name() const
{
return "OpenRouter";
}
QString OpenRouterProvider::url() const
{
return "https://openrouter.ai/api";
}
QString OpenRouterProvider::apiKey() const
{
return Settings::providerSettings().openRouterApiKey();
}
LLMCore::ProviderID OpenRouterProvider::providerID() const
QString OpenRouterProvider::url() const
{
return LLMCore::ProviderID::OpenRouter;
return "https://openrouter.ai/api";
}
PluginLLMCore::ProviderID OpenRouterProvider::providerID() const
{
return PluginLLMCore::ProviderID::OpenRouter;
}
} // namespace QodeAssist::Providers

4
providers/OpenRouterAIProvider.hpp
View File

@@ -26,10 +26,12 @@ namespace QodeAssist::Providers {
class OpenRouterProvider : public OpenAICompatProvider
{
public:
explicit OpenRouterProvider(QObject *parent = nullptr);
QString name() const override;
QString url() const override;
QString apiKey() const override;
LLMCore::ProviderID providerID() const override;
PluginLLMCore::ProviderID providerID() const override;
};
} // namespace QodeAssist::Providers

4
providers/Providers.hpp
View File

@@ -19,7 +19,7 @@
#pragma once
#include "llmcore/ProvidersManager.hpp"
#include "pluginllmcore/ProvidersManager.hpp"
#include "providers/ClaudeProvider.hpp"
#include "providers/CodestralProvider.hpp"
#include "providers/GoogleAIProvider.hpp"
@@ -36,7 +36,7 @@ namespace QodeAssist::Providers {
inline void registerProviders()
{
auto &providerManager = LLMCore::ProvidersManager::instance();
auto &providerManager = PluginLLMCore::ProvidersManager::instance();
providerManager.registerProvider<OllamaProvider>();
providerManager.registerProvider<ClaudeProvider>();
providerManager.registerProvider<OpenAIProvider>();

10
qodeassist.cpp
View File

@@ -50,8 +50,8 @@
#include "chat/ChatOutputPane.h"
#include "chat/NavigationPanel.hpp"
#include "context/DocumentReaderQtCreator.hpp"
#include "llmcore/PromptProviderFim.hpp"
#include "llmcore/ProvidersManager.hpp"
#include "pluginllmcore/PromptProviderFim.hpp"
#include "pluginllmcore/ProvidersManager.hpp"
#include "logger/RequestPerformanceLogger.hpp"
#include "providers/Providers.hpp"
#include "settings/ChatAssistantSettings.hpp"
@@ -84,7 +84,7 @@ class QodeAssistPlugin final : public ExtensionSystem::IPlugin
public:
QodeAssistPlugin()
: m_updater(new PluginUpdater(this))
, m_promptProvider(LLMCore::PromptTemplateManager::instance())
, m_promptProvider(PluginLLMCore::PromptTemplateManager::instance())
{}
~QodeAssistPlugin() final
@@ -263,7 +263,7 @@ public:
m_qodeAssistClient = new QodeAssistClient(new LLMClientInterface(
Settings::generalSettings(),
Settings::codeCompletionSettings(),
LLMCore::ProvidersManager::instance(),
PluginLLMCore::ProvidersManager::instance(),
&m_promptProvider,
m_documentReader,
m_performanceLogger));
@@ -305,7 +305,7 @@ private:
}
QPointer<QodeAssistClient> m_qodeAssistClient;
LLMCore::PromptProviderFim m_promptProvider;
PluginLLMCore::PromptProviderFim m_promptProvider;
Context::DocumentReaderQtCreator m_documentReader;
RequestPerformanceLogger m_performanceLogger;
QPointer<Chat::ChatOutputPane> m_chatOutputPane;

2
settings/GeneralSettings.hpp
View File

@@ -29,7 +29,7 @@ namespace Utils {
class DetailsWidget;
}
namespace QodeAssist::LLMCore {
namespace QodeAssist::PluginLLMCore {
class Provider;
}
namespace QodeAssist::Settings {

1
sources/external/llmcore vendored Submodule

Submodule sources/external/llmcore added at d1fb0dca95

20
templates/Alpaca.hpp
View File

@@ -19,21 +19,21 @@
#pragma once
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
#include <QJsonArray>
namespace QodeAssist::Templates {
class Alpaca : public LLMCore::PromptTemplate
class Alpaca : public PluginLLMCore::PromptTemplate
{
public:
QString name() const override { return "Alpaca"; }
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::Chat; }
QStringList stopWords() const override
{
return QStringList() << "### Instruction:" << "### Response:";
}
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
QJsonArray messages;
@@ -72,14 +72,14 @@ public:
"}\n\n"
"Combines all messages into a single formatted prompt.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case LLMCore::ProviderID::Ollama:
case LLMCore::ProviderID::LMStudio:
case LLMCore::ProviderID::OpenRouter:
case LLMCore::ProviderID::OpenAICompatible:
case LLMCore::ProviderID::LlamaCpp:
case PluginLLMCore::ProviderID::Ollama:
case PluginLLMCore::ProviderID::LMStudio:
case PluginLLMCore::ProviderID::OpenRouter:
case PluginLLMCore::ProviderID::OpenAICompatible:
case PluginLLMCore::ProviderID::LlamaCpp:
return true;
default:
return false;

20
templates/ChatML.hpp
View File

@@ -21,20 +21,20 @@
#include <QJsonArray>
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
namespace QodeAssist::Templates {
class ChatML : public LLMCore::PromptTemplate
class ChatML : public PluginLLMCore::PromptTemplate
{
public:
QString name() const override { return "ChatML"; }
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::Chat; }
QStringList stopWords() const override
{
return QStringList() << "<|im_start|>" << "<|im_end|>";
}
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
QJsonArray messages;
@@ -73,14 +73,14 @@ public:
"}\n\n"
"Compatible with multiple providers supporting the ChatML token format.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case LLMCore::ProviderID::Ollama:
case LLMCore::ProviderID::LMStudio:
case LLMCore::ProviderID::OpenRouter:
case LLMCore::ProviderID::OpenAICompatible:
case LLMCore::ProviderID::LlamaCpp:
case PluginLLMCore::ProviderID::Ollama:
case PluginLLMCore::ProviderID::LMStudio:
case PluginLLMCore::ProviderID::OpenRouter:
case PluginLLMCore::ProviderID::OpenAICompatible:
case PluginLLMCore::ProviderID::LlamaCpp:
return true;
default:
return false;

12
templates/Claude.hpp
View File

@@ -21,17 +21,17 @@
#include <QJsonArray>
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
namespace QodeAssist::Templates {
class Claude : public LLMCore::PromptTemplate
class Claude : public PluginLLMCore::PromptTemplate
{
public:
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::Chat; }
QString name() const override { return "Claude"; }
QStringList stopWords() const override { return QStringList(); }
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
QJsonArray messages;
@@ -111,10 +111,10 @@ public:
"}\n\n"
"Formats content according to Claude API specifications.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case QodeAssist::LLMCore::ProviderID::Claude:
case QodeAssist::PluginLLMCore::ProviderID::Claude:
return true;
default:
return false;

12
templates/CodeLlamaFim.hpp
View File

@@ -19,20 +19,20 @@
#pragma once
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
namespace QodeAssist::Templates {
class CodeLlamaFim : public LLMCore::PromptTemplate
class CodeLlamaFim : public PluginLLMCore::PromptTemplate
{
public:
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::FIM; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::FIM; }
QString name() const override { return "CodeLlama FIM"; }
QStringList stopWords() const override
{
return QStringList() << "<EOT>" << "<PRE>" << "<SUF" << "<MID>";
}
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
request["prompt"] = QString("<PRE> %1 <SUF>%2 <MID>")
.arg(context.prefix.value_or(""), context.suffix.value_or(""));
@@ -47,10 +47,10 @@ public:
"}\n\n"
"Optimized for code completion with CodeLlama models.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case QodeAssist::LLMCore::ProviderID::Ollama:
case QodeAssist::PluginLLMCore::ProviderID::Ollama:
return true;
default:
return false;

12
templates/CodeLlamaQMLFim.hpp
View File

@@ -19,21 +19,21 @@
#pragma once
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
namespace QodeAssist::Templates {
class CodeLlamaQMLFim : public LLMCore::PromptTemplate
class CodeLlamaQMLFim : public PluginLLMCore::PromptTemplate
{
public:
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::FIM; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::FIM; }
QString name() const override { return "CodeLlama QML FIM"; }
QStringList stopWords() const override
{
return QStringList() << "<SUF>" << "<PRE>" << "</PRE>" << "</SUF>" << "< EOT >" << "\\end"
<< "<MID>" << "</MID>" << "##";
}
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
request["prompt"] = QString("<SUF>%1<PRE>%2<MID>")
.arg(context.suffix.value_or(""), context.prefix.value_or(""));
@@ -48,10 +48,10 @@ public:
"}\n\n"
"Specifically optimized for QML/JavaScript code completion.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case QodeAssist::LLMCore::ProviderID::Ollama:
case QodeAssist::PluginLLMCore::ProviderID::Ollama:
return true;
default:
return false;

12
templates/GoogleAI.hpp
View File

@@ -22,18 +22,18 @@
#include <QJsonArray>
#include <QJsonObject>
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
namespace QodeAssist::Templates {
class GoogleAI : public LLMCore::PromptTemplate
class GoogleAI : public PluginLLMCore::PromptTemplate
{
public:
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::Chat; }
QString name() const override { return "Google AI"; }
QStringList stopWords() const override { return QStringList(); }
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
QJsonArray contents;
@@ -128,9 +128,9 @@ public:
"Supports proper role mapping (model/user roles), images, and thinking blocks.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
return id == QodeAssist::LLMCore::ProviderID::GoogleAI;
return id == QodeAssist::PluginLLMCore::ProviderID::GoogleAI;
}
};

20
templates/Llama2.hpp
View File

@@ -19,18 +19,18 @@
#pragma once
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
#include <QJsonArray>
namespace QodeAssist::Templates {
class Llama2 : public LLMCore::PromptTemplate
class Llama2 : public PluginLLMCore::PromptTemplate
{
public:
QString name() const override { return "Llama 2"; }
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::Chat; }
QStringList stopWords() const override { return QStringList() << "[INST]"; }
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
QJsonArray messages;
@@ -70,14 +70,14 @@ public:
"}\n\n"
"Compatible with Ollama, LM Studio, and other services for Llama 2.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case LLMCore::ProviderID::Ollama:
case LLMCore::ProviderID::LMStudio:
case LLMCore::ProviderID::OpenRouter:
case LLMCore::ProviderID::OpenAICompatible:
case LLMCore::ProviderID::LlamaCpp:
case PluginLLMCore::ProviderID::Ollama:
case PluginLLMCore::ProviderID::LMStudio:
case PluginLLMCore::ProviderID::OpenRouter:
case PluginLLMCore::ProviderID::OpenAICompatible:
case PluginLLMCore::ProviderID::LlamaCpp:
return true;
default:
return false;

20
templates/Llama3.hpp
View File

@@ -21,20 +21,20 @@
#include <QJsonArray>
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
namespace QodeAssist::Templates {
class Llama3 : public LLMCore::PromptTemplate
class Llama3 : public PluginLLMCore::PromptTemplate
{
public:
QString name() const override { return "Llama 3"; }
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::Chat; }
QStringList stopWords() const override
{
return QStringList() << "<|start_header_id|>" << "<|end_header_id|>" << "<|eot_id|>";
}
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
QJsonArray messages;
@@ -77,14 +77,14 @@ public:
"}\n\n"
"Compatible with Ollama, LM Studio, and OpenAI-compatible services for Llama 3.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case LLMCore::ProviderID::Ollama:
case LLMCore::ProviderID::LMStudio:
case LLMCore::ProviderID::OpenRouter:
case LLMCore::ProviderID::OpenAICompatible:
case LLMCore::ProviderID::LlamaCpp:
case PluginLLMCore::ProviderID::Ollama:
case PluginLLMCore::ProviderID::LMStudio:
case PluginLLMCore::ProviderID::OpenRouter:
case PluginLLMCore::ProviderID::OpenAICompatible:
case PluginLLMCore::ProviderID::LlamaCpp:
return true;
default:
return false;

12
templates/LlamaCppFim.hpp
View File

@@ -21,18 +21,18 @@
#include <QJsonArray>
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
namespace QodeAssist::Templates {
class LlamaCppFim : public LLMCore::PromptTemplate
class LlamaCppFim : public PluginLLMCore::PromptTemplate
{
public:
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::FIM; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::FIM; }
QString name() const override { return "llama.cpp FIM"; }
QStringList stopWords() const override { return {}; }
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
request["input_prefix"] = context.prefix.value_or("");
request["input_suffix"] = context.suffix.value_or("");
@@ -60,9 +60,9 @@ public:
"Recommended for models with FIM capability.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
return id == QodeAssist::LLMCore::ProviderID::LlamaCpp;
return id == QodeAssist::PluginLLMCore::ProviderID::LlamaCpp;
}
};

22
templates/MistralAI.hpp
View File

@@ -21,17 +21,17 @@
#include <QJsonArray>
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
namespace QodeAssist::Templates {
class MistralAIFim : public LLMCore::PromptTemplate
class MistralAIFim : public PluginLLMCore::PromptTemplate
{
public:
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::FIM; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::FIM; }
QString name() const override { return "Mistral AI FIM"; }
QStringList stopWords() const override { return QStringList(); }
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
request["prompt"] = context.prefix.value_or("");
request["suffix"] = context.suffix.value_or("");
@@ -45,10 +45,10 @@ public:
"}\n\n"
"Optimized for code completion with MistralAI models.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case QodeAssist::LLMCore::ProviderID::MistralAI:
case QodeAssist::PluginLLMCore::ProviderID::MistralAI:
return true;
default:
return false;
@@ -56,14 +56,14 @@ public:
}
};
class MistralAIChat : public LLMCore::PromptTemplate
class MistralAIChat : public PluginLLMCore::PromptTemplate
{
public:
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::Chat; }
QString name() const override { return "Mistral AI Chat"; }
QStringList stopWords() const override { return QStringList(); }
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
QJsonArray messages;
@@ -116,10 +116,10 @@ public:
"}\n\n"
"Supports system messages, conversation history, and images.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case QodeAssist::LLMCore::ProviderID::MistralAI:
case QodeAssist::PluginLLMCore::ProviderID::MistralAI:
return true;
default:
return false;

22
templates/Ollama.hpp
View File

@@ -21,17 +21,17 @@
#include <QJsonArray>
#include "llmcore/PromptTemplate.hpp"
#include "pluginllmcore/PromptTemplate.hpp"
namespace QodeAssist::Templates {
class OllamaFim : public LLMCore::PromptTemplate
class OllamaFim : public PluginLLMCore::PromptTemplate
{
public:
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::FIM; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::FIM; }
QString name() const override { return "Ollama FIM"; }
QStringList stopWords() const override { return QStringList() << "<EOT>"; }
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
request["prompt"] = context.prefix.value_or("");
request["suffix"] = context.suffix.value_or("");
@@ -47,10 +47,10 @@ public:
"}\n\n"
"Recommended for Ollama models with FIM capability.";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case QodeAssist::LLMCore::ProviderID::Ollama:
case QodeAssist::PluginLLMCore::ProviderID::Ollama:
return true;
default:
return false;
@@ -58,14 +58,14 @@ public:
}
};
class OllamaChat : public LLMCore::PromptTemplate
class OllamaChat : public PluginLLMCore::PromptTemplate
{
public:
LLMCore::TemplateType type() const override { return LLMCore::TemplateType::Chat; }
PluginLLMCore::TemplateType type() const override { return PluginLLMCore::TemplateType::Chat; }
QString name() const override { return "Ollama Chat"; }
QStringList stopWords() const override { return QStringList(); }
void prepareRequest(QJsonObject &request, const LLMCore::ContextData &context) const override
void prepareRequest(QJsonObject &request, const PluginLLMCore::ContextData &context) const override
{
QJsonArray messages;
@@ -107,10 +107,10 @@ public:
"Recommended for Ollama models with chat capability.\n"
"Supports images for multimodal models (e.g., llava).";
}
bool isSupportProvider(LLMCore::ProviderID id) const override
bool isSupportProvider(PluginLLMCore::ProviderID id) const override
{
switch (id) {
case QodeAssist::LLMCore::ProviderID::Ollama:
case QodeAssist::PluginLLMCore::ProviderID::Ollama:
return true;
default:
return false;

Some files were not shown because too many files have changed in this diff Show More