refactor: final Agent loader

CMakeLists.txt

@@ -1,10 +1,8 @@
 cmake_minimum_required(VERSION 3.16)
 
-project(QodeAssist)
+list(APPEND CMAKE_PREFIX_PATH "/Users/palm1r/Qt/Qt Creator.sdk/lib/cmake/QtCreator")
 
-option(QODEASSIST_EXPERIMENTAL
-       "Enable experimental features" OFF)
-message(STATUS "QodeAssist experimental features: ${QODEASSIST_EXPERIMENTAL}")
+project(QodeAssist)
 
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
@@ -42,7 +40,6 @@ add_definitions(
 
 add_subdirectory(sources)
 add_subdirectory(logger)
-add_subdirectory(pluginllmcore)
 add_subdirectory(settings)
 add_subdirectory(UIControls)
 add_subdirectory(ChatView)
@@ -51,6 +48,11 @@ if(GTest_FOUND)
   add_subdirectory(test)
 endif()
 
+option(QODEASSIST_BUILD_BENCH "Build the standalone agent bench CLI" ON)
+if(QODEASSIST_BUILD_BENCH)
+  add_subdirectory(bench)
+endif()
+
 add_qtc_plugin(QodeAssist
   PLUGIN_DEPENDS
     QtCreator::Core
@@ -69,7 +71,6 @@ add_qtc_plugin(QodeAssist
     QtCreator::Utils
     QtCreator::CPlusPlus
     LLMQore
-    PluginLLMCore
     ProvidersConfig
     Agents
     Skills
@@ -83,42 +84,6 @@ add_qtc_plugin(QodeAssist
     QodeAssisttr.h
     LLMClientInterface.hpp LLMClientInterface.cpp
     RefactorContextHelper.hpp
-    templates/Templates.hpp
-    templates/CodeLlamaFim.hpp
-    templates/Ollama.hpp
-    templates/Claude.hpp
-    templates/OpenAI.hpp
-    templates/MistralAI.hpp
-    templates/StarCoder2Fim.hpp
-    templates/Qwen25CoderFIM.hpp
-    templates/OpenAICompatible.hpp
-    templates/Llama3.hpp
-    templates/ChatML.hpp
-    templates/Alpaca.hpp
-    templates/Llama2.hpp
-    templates/CodeLlamaQMLFim.hpp
-    templates/GoogleAI.hpp
-    templates/LlamaCppFim.hpp
-    templates/Qwen3CoderFIM.hpp
-    templates/OpenAIResponses.hpp
-    providers/Providers.hpp
-    providers/ProviderUrlUtils.hpp
-    providers/OllamaProvider.hpp providers/OllamaProvider.cpp
-    providers/OllamaCompatProvider.hpp providers/OllamaCompatProvider.cpp
-    providers/ClaudeProvider.hpp providers/ClaudeProvider.cpp
-    providers/OpenAIProvider.hpp providers/OpenAIProvider.cpp
-    providers/MistralAIProvider.hpp providers/MistralAIProvider.cpp
-    providers/LMStudioProvider.hpp providers/LMStudioProvider.cpp
-    providers/LMStudioResponsesProvider.hpp providers/LMStudioResponsesProvider.cpp
-    providers/OpenAICompatProvider.hpp providers/OpenAICompatProvider.cpp
-    providers/OpenRouterAIProvider.hpp providers/OpenRouterAIProvider.cpp
-    providers/GoogleAIProvider.hpp providers/GoogleAIProvider.cpp
-    providers/LlamaCppProvider.hpp providers/LlamaCppProvider.cpp
-    providers/CodestralProvider.hpp providers/CodestralProvider.cpp
-    providers/OpenAIResponsesProvider.hpp providers/OpenAIResponsesProvider.cpp
-    providers/QwenProvider.hpp providers/QwenProvider.cpp
-    providers/QwenResponsesProvider.hpp providers/QwenResponsesProvider.cpp
-    providers/DeepSeekProvider.hpp providers/DeepSeekProvider.cpp
     QodeAssist.qrc
     LSPCompletion.hpp
     LLMSuggestion.hpp LLMSuggestion.cpp
@@ -130,7 +95,6 @@ add_qtc_plugin(QodeAssist
     chat/ChatDocument.hpp chat/ChatDocument.cpp
     chat/ChatEditor.hpp chat/ChatEditor.cpp
     chat/ChatEditorFactory.hpp chat/ChatEditorFactory.cpp
-    ConfigurationManager.hpp ConfigurationManager.cpp
     CodeHandler.hpp CodeHandler.cpp
     UpdateStatusWidget.hpp UpdateStatusWidget.cpp
     widgets/CompletionProgressHandler.hpp widgets/CompletionProgressHandler.cpp
@@ -170,10 +134,7 @@ add_qtc_plugin(QodeAssist
     settings/McpClientsListAspect.hpp settings/McpClientsListAspect.cpp
 )
 
-if(QODEASSIST_EXPERIMENTAL)
-    target_compile_definitions(QodeAssist PRIVATE QODEASSIST_EXPERIMENTAL)
-    target_link_libraries(QodeAssist PRIVATE QodeAssistAgentPipelines)
-endif()
+target_link_libraries(QodeAssist PRIVATE QodeAssistAgentPipelines Session)
 
 get_target_property(QtCreatorCorePath QtCreator::Core LOCATION)
 find_program(QtCreatorExecutable

ChatView/AgentRoleController.cpp

@@ -1,123 +0,0 @@
-// Copyright (C) 2024-2026 Petr Mironychev
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "AgentRoleController.hpp"
-
-#include <utils/aspects.h>
-
-#include "AgentRole.hpp"
-#include "ChatAssistantSettings.hpp"
-#include "GeneralSettings.hpp"
-
-namespace QodeAssist::Chat {
-
-AgentRoleController::AgentRoleController(QObject *parent)
-    : QObject(parent)
-{
-    connect(
-        &Settings::chatAssistantSettings().systemPrompt,
-        &Utils::BaseAspect::changed,
-        this,
-        &AgentRoleController::baseSystemPromptChanged);
-
-    loadAvailableRoles();
-}
-
-QStringList AgentRoleController::availableRoles() const
-{
-    return m_availableRoles;
-}
-
-QString AgentRoleController::currentRole() const
-{
-    return m_currentRole;
-}
-
-QString AgentRoleController::baseSystemPrompt() const
-{
-    return Settings::chatAssistantSettings().systemPrompt();
-}
-
-QString AgentRoleController::currentRoleDescription() const
-{
-    const QString lastRoleId = Settings::chatAssistantSettings().lastUsedRoleId();
-    if (lastRoleId.isEmpty())
-        return Settings::AgentRolesManager::getNoRole().description;
-
-    const Settings::AgentRole role = Settings::AgentRolesManager::loadRole(lastRoleId);
-    if (role.id.isEmpty())
-        return Settings::AgentRolesManager::getNoRole().description;
-
-    return role.description;
-}
-
-QString AgentRoleController::currentRoleSystemPrompt() const
-{
-    const QString lastRoleId = Settings::chatAssistantSettings().lastUsedRoleId();
-    if (lastRoleId.isEmpty())
-        return QString();
-
-    const Settings::AgentRole role = Settings::AgentRolesManager::loadRole(lastRoleId);
-    if (role.id.isEmpty())
-        return QString();
-
-    return role.systemPrompt;
-}
-
-void AgentRoleController::loadAvailableRoles()
-{
-    const QList<Settings::AgentRole> roles = Settings::AgentRolesManager::loadAllRoles();
-
-    m_availableRoles.clear();
-    m_availableRoles.append(Settings::AgentRolesManager::getNoRole().name);
-
-    for (const auto &role : roles)
-        m_availableRoles.append(role.name);
-
-    const QString lastRoleId = Settings::chatAssistantSettings().lastUsedRoleId();
-    m_currentRole = Settings::AgentRolesManager::getNoRole().name;
-
-    if (!lastRoleId.isEmpty()) {
-        for (const auto &role : roles) {
-            if (role.id == lastRoleId) {
-                m_currentRole = role.name;
-                break;
-            }
-        }
-    }
-
-    emit availableRolesChanged();
-    emit currentRoleChanged();
-}
-
-void AgentRoleController::applyRole(const QString &roleName)
-{
-    auto &settings = Settings::chatAssistantSettings();
-
-    if (roleName == Settings::AgentRolesManager::getNoRole().name) {
-        settings.lastUsedRoleId.setValue("");
-        settings.writeSettings();
-        m_currentRole = roleName;
-        emit currentRoleChanged();
-        return;
-    }
-
-    const QList<Settings::AgentRole> roles = Settings::AgentRolesManager::loadAllRoles();
-
-    for (const auto &role : roles) {
-        if (role.name == roleName) {
-            settings.lastUsedRoleId.setValue(role.id);
-            settings.writeSettings();
-            m_currentRole = role.name;
-            emit currentRoleChanged();
-            break;
-        }
-    }
-}
-
-void AgentRoleController::openSettings()
-{
-    Settings::showSettings(Utils::Id("QodeAssist.AgentRoles"));
-}
-
-} // namespace QodeAssist::Chat

ChatView/AgentRoleController.hpp

@@ -1,38 +0,0 @@
-// Copyright (C) 2024-2026 Petr Mironychev
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <QObject>
-#include <QStringList>
-
-namespace QodeAssist::Chat {
-
-class AgentRoleController : public QObject
-{
-    Q_OBJECT
-
-public:
-    explicit AgentRoleController(QObject *parent = nullptr);
-
-    QStringList availableRoles() const;
-    QString currentRole() const;
-    QString baseSystemPrompt() const;
-    QString currentRoleDescription() const;
-    QString currentRoleSystemPrompt() const;
-
-    void loadAvailableRoles();
-    void applyRole(const QString &roleName);
-    void openSettings();
-
-signals:
-    void availableRolesChanged();
-    void currentRoleChanged();
-    void baseSystemPromptChanged();
-
-private:
-    QStringList m_availableRoles;
-    QString m_currentRole;
-};
-
-} // namespace QodeAssist::Chat

ChatView/CMakeLists.txt

@@ -45,6 +45,7 @@ qt_add_qml_module(QodeAssistChatView
     icons/window-unlock.svg
     icons/chat-icon.svg
     icons/chat-pause-icon.svg
+    icons/warning-icon.svg
     icons/new-chat-icon.svg
     icons/rules-icon.svg
     icons/context-icon.svg
@@ -74,8 +75,7 @@ qt_add_qml_module(QodeAssistChatView
     FileItem.hpp FileItem.cpp
     ChatFileManager.hpp ChatFileManager.cpp
     ChatCompressor.hpp ChatCompressor.cpp
-    AgentRoleController.hpp AgentRoleController.cpp
-    ChatConfigurationController.hpp ChatConfigurationController.cpp
+    ChatAgentController.hpp ChatAgentController.cpp
     FileEditController.hpp FileEditController.cpp
     InputTokenCounter.hpp InputTokenCounter.cpp
     ChatHistoryStore.hpp ChatHistoryStore.cpp
@@ -91,13 +91,14 @@ target_link_libraries(QodeAssistChatView
     Qt::Network
     QtCreator::Core
     QtCreator::Utils
-    PluginLLMCore
     QodeAssistSettings
     Context
     QodeAssistUIControlsplugin
     QodeAssistLogger
     LLMQore
     Skills
+    Agents
+    Session
 )
 
 target_include_directories(QodeAssistChatView

ChatView/ChatAgentController.cpp

@@ -0,0 +1,105 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "ChatAgentController.hpp"
+
+#include <QSettings>
+
+#include <coreplugin/icore.h>
+
+#include <AgentConfig.hpp>
+#include <AgentFactory.hpp>
+#include <sources/settings/PipelinesConfig.hpp>
+
+namespace QodeAssist::Chat {
+
+namespace {
+const char kChatAgentKey[] = "QodeAssist.chatActiveAgent";
+}
+
+ChatAgentController::ChatAgentController(QObject *parent)
+    : QObject(parent)
+{
+    if (auto *settings = Core::ICore::settings())
+        m_currentAgent = settings->value(kChatAgentKey).toString();
+}
+
+void ChatAgentController::setAgentFactory(AgentFactory *factory)
+{
+    m_agentFactory = factory;
+    reload();
+}
+
+QStringList ChatAgentController::availableAgents() const
+{
+    return m_availableAgents;
+}
+
+QString ChatAgentController::currentAgent() const
+{
+    return m_currentAgent;
+}
+
+void ChatAgentController::setCurrentAgent(const QString &name)
+{
+    if (name == m_currentAgent || !m_availableAgents.contains(name))
+        return;
+
+    m_currentAgent = name;
+    if (auto *settings = Core::ICore::settings())
+        settings->setValue(kChatAgentKey, m_currentAgent);
+    emit currentAgentChanged();
+}
+
+void ChatAgentController::reload()
+{
+    const QStringList all = m_agentFactory ? m_agentFactory->configNames() : QStringList{};
+    const QStringList roster = Settings::PipelinesConfig::load().rosters.chatAssistant;
+
+    if (roster.isEmpty()) {
+        m_availableAgents = all;
+    } else {
+        QStringList filtered;
+        for (const QString &name : roster) {
+            if (all.contains(name))
+                filtered.append(name);
+        }
+        m_availableAgents = filtered.isEmpty() ? all : filtered;
+    }
+
+    emit availableAgentsChanged();
+    ensureValidCurrent();
+}
+
+void ChatAgentController::ensureValidCurrent()
+{
+    if (m_availableAgents.contains(m_currentAgent))
+        return;
+
+    const QString next = m_availableAgents.isEmpty() ? QString() : m_availableAgents.first();
+    if (next == m_currentAgent)
+        return;
+
+    m_currentAgent = next;
+    if (auto *settings = Core::ICore::settings())
+        settings->setValue(kChatAgentKey, m_currentAgent);
+    emit currentAgentChanged();
+}
+
+bool ChatAgentController::currentSupportsThinking() const
+{
+    if (!m_agentFactory || m_currentAgent.isEmpty())
+        return false;
+    const AgentConfig *config = m_agentFactory->configByName(m_currentAgent);
+    return config && config->enableThinking;
+}
+
+bool ChatAgentController::currentSupportsTools() const
+{
+    if (!m_agentFactory || m_currentAgent.isEmpty())
+        return false;
+    const AgentConfig *config = m_agentFactory->configByName(m_currentAgent);
+    return config && config->enableTools;
+}
+
+} // namespace QodeAssist::Chat

ChatView/ChatAgentController.hpp

@@ -0,0 +1,47 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <QObject>
+#include <QPointer>
+#include <QString>
+#include <QStringList>
+
+namespace QodeAssist {
+class AgentFactory;
+}
+
+namespace QodeAssist::Chat {
+
+class ChatAgentController : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit ChatAgentController(QObject *parent = nullptr);
+
+    void setAgentFactory(AgentFactory *factory);
+
+    QStringList availableAgents() const;
+    QString currentAgent() const;
+    void setCurrentAgent(const QString &name);
+
+    bool currentSupportsThinking() const;
+    bool currentSupportsTools() const;
+
+    void reload();
+
+signals:
+    void availableAgentsChanged();
+    void currentAgentChanged();
+
+private:
+    void ensureValidCurrent();
+
+    QPointer<AgentFactory> m_agentFactory;
+    QStringList m_availableAgents;
+    QString m_currentAgent;
+};
+
+} // namespace QodeAssist::Chat

ChatView/ChatCompressor.cpp

@@ -1,15 +1,23 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "ChatCompressor.hpp"
 
+#include <memory>
+
 #include <LLMQore/BaseClient.hpp>
-#include "ChatModel.hpp"
+#include <LLMQore/ContentBlocks.hpp>
+
 #include "GeneralSettings.hpp"
-#include "PromptTemplateManager.hpp"
-#include "ProvidersManager.hpp"
 #include "logger/Logger.hpp"
 
+#include <ConversationHistory.hpp>
+#include <Message.hpp>
+#include <Session.hpp>
+#include <SessionManager.hpp>
+#include <SystemPromptBuilder.hpp>
+
 #include <QDateTime>
 #include <QFile>
 #include <QFileInfo>
@@ -24,7 +32,18 @@ ChatCompressor::ChatCompressor(QObject *parent)
     : QObject(parent)
 {}
 
-void ChatCompressor::startCompression(const QString &chatFilePath, ChatModel *chatModel)
+void ChatCompressor::setSessionManager(SessionManager *sessionManager)
+{
+    m_sessionManager = sessionManager;
+}
+
+void ChatCompressor::setActiveAgent(const QString &agentName)
+{
+    m_activeAgent = agentName;
+}
+
+void ChatCompressor::startCompression(
+    const QString &chatFilePath, ConversationHistory *sourceHistory)
 {
     if (m_isCompressing) {
         emit compressionFailed(tr("Compression already in progress"));
@@ -36,47 +55,78 @@ void ChatCompressor::startCompression(const QString &chatFilePath, ChatModel *ch
         return;
     }
 
-    if (!chatModel || chatModel->rowCount() == 0) {
+    if (!sourceHistory || sourceHistory->isEmpty()) {
         emit compressionFailed(tr("Chat is empty, nothing to compress"));
         return;
     }
 
-    auto providerName = Settings::generalSettings().caProvider();
-    m_provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
-
-    if (!m_provider) {
-        emit compressionFailed(tr("No provider available"));
+    if (!m_sessionManager) {
+        emit compressionFailed(tr("Chat session manager is not available"));
         return;
     }
 
-    auto templateName = Settings::generalSettings().caTemplate();
-    auto promptTemplate = PluginLLMCore::PromptTemplateManager::instance().getChatTemplateByName(
-        templateName);
+    QString sessionError;
+    Session *session = m_sessionManager->acquire(m_activeAgent, &sessionError);
+    if (!session) {
+        emit compressionFailed(
+            sessionError.isEmpty() ? tr("No chat agent selected") : sessionError);
+        return;
+    }
 
-    if (!promptTemplate) {
-        emit compressionFailed(tr("No template available"));
+    auto *client = session->client();
+    if (!client) {
+        m_sessionManager->removeSession(session);
+        emit compressionFailed(tr("Chat agent has no live client"));
         return;
     }
 
     m_isCompressing = true;
-    m_chatModel = chatModel;
     m_originalChatPath = chatFilePath;
-    m_accumulatedSummary.clear();
+    m_session = session;
 
     emit compressionStarted();
 
-    connectProviderSignals();
+    session->systemPrompt()->setLayer(
+        QStringLiteral("compression"),
+        QStringLiteral(
+            "You are a helpful assistant that creates concise summaries of conversations. "
+            "Your summaries preserve key information, technical details, and the flow of "
+            "discussion."));
 
-    QJsonObject payload{
-        {"model", Settings::generalSettings().caModel()}, {"stream", true}};
+    auto *history = session->history();
+    for (const auto &msg : sourceHistory->messages()) {
+        if (msg.role() != Message::Role::User && msg.role() != Message::Role::Assistant)
+            continue;
+        const QString text = msg.text();
+        if (text.trimmed().isEmpty())
+            continue;
 
-    buildRequestPayload(payload, promptTemplate);
+        Message apiMessage(msg.role());
+        apiMessage.appendBlock(std::make_unique<LLMQore::TextContent>(text));
+        history->append(std::move(apiMessage));
+    }
 
-    const QString customEndpoint = Settings::generalSettings().caCustomEndpoint();
-    const QString endpoint = !customEndpoint.isEmpty() ? customEndpoint
-                                                       : promptTemplate->endpoint();
-    m_currentRequestId = m_provider->sendRequest(
-        QUrl(Settings::generalSettings().caUrl()), payload, endpoint);
+    connect(
+        session, &Session::finished, this,
+        [this](const LLMQore::RequestID &id, const QString &) { onCompressionFinished(id); });
+    connect(
+        session, &Session::failed, this,
+        [this](const LLMQore::RequestID &id, const QodeAssist::ErrorInfo &error) {
+            onCompressionFailed(id, error.message);
+        });
+
+    client->setTransferTimeout(
+        static_cast<int>(Settings::generalSettings().requestTimeout() * 1000));
+
+    std::vector<std::unique_ptr<LLMQore::ContentBlock>> blocks;
+    blocks.push_back(std::make_unique<LLMQore::TextContent>(buildCompressionPrompt()));
+
+    m_currentRequestId = session->send(std::move(blocks), /*toolsOverride=*/false);
+    if (m_currentRequestId.isEmpty()) {
+        handleCompressionError(tr("Failed to start compression request: %1")
+                                   .arg(session->lastError().message));
+        return;
+    }
     LOG_MESSAGE(QString("Starting compression request: %1").arg(m_currentRequestId));
 }
 
@@ -91,44 +141,38 @@ void ChatCompressor::cancelCompression()
         return;
 
     LOG_MESSAGE("Cancelling compression request");
-
-    if (m_provider && !m_currentRequestId.isEmpty())
-        m_provider->cancelRequest(m_currentRequestId);
-
     cleanupState();
     emit compressionFailed(tr("Compression cancelled"));
 }
 
-void ChatCompressor::onPartialResponseReceived(const QString &requestId, const QString &partialText)
+void ChatCompressor::onCompressionFinished(const QString &requestId)
 {
     if (!m_isCompressing || requestId != m_currentRequestId)
         return;
 
-    m_accumulatedSummary += partialText;
-}
+    QString summary;
+    if (m_session) {
+        if (auto *history = m_session->history(); history && !history->isEmpty())
+            summary = history->messages().back().text();
+    }
 
-void ChatCompressor::onFullResponseReceived(const QString &requestId, const QString &fullText)
-{
-    Q_UNUSED(fullText)
+    LOG_MESSAGE(QString("Received summary, length: %1 characters").arg(summary.length()));
 
-    if (!m_isCompressing || requestId != m_currentRequestId)
-        return;
+    const QString compressedPath = createCompressedChatPath(m_originalChatPath);
+    const QString sourcePath = m_originalChatPath;
 
-    LOG_MESSAGE(
-        QString("Received summary, length: %1 characters").arg(m_accumulatedSummary.length()));
+    cleanupState();
 
-    QString compressedPath = createCompressedChatPath(m_originalChatPath);
-    if (!createCompressedChatFile(m_originalChatPath, compressedPath, m_accumulatedSummary)) {
-        handleCompressionError(tr("Failed to save compressed chat"));
+    if (!createCompressedChatFile(sourcePath, compressedPath, summary)) {
+        emit compressionFailed(tr("Failed to save compressed chat"));
         return;
     }
 
     LOG_MESSAGE(QString("Compression completed: %1").arg(compressedPath));
-    cleanupState();
     emit compressionCompleted(compressedPath);
 }
 
-void ChatCompressor::onRequestFailed(const QString &requestId, const QString &error)
+void ChatCompressor::onCompressionFailed(const QString &requestId, const QString &error)
 {
     if (!m_isCompressing || requestId != m_currentRequestId)
         return;
@@ -165,39 +209,6 @@ QString ChatCompressor::buildCompressionPrompt() const
         "Create the summary now:");
 }
 
-void ChatCompressor::buildRequestPayload(
-    QJsonObject &payload, PluginLLMCore::PromptTemplate *promptTemplate)
-{
-    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<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;
-
-        PluginLLMCore::Message apiMessage;
-        apiMessage.role = (msg.role == ChatModel::ChatRole::User) ? "user" : "assistant";
-        apiMessage.content = msg.content;
-        messages.append(apiMessage);
-    }
-
-    PluginLLMCore::Message compressionRequest;
-    compressionRequest.role = "user";
-    compressionRequest.content = buildCompressionPrompt();
-    messages.append(compressionRequest);
-
-    context.history = messages;
-
-    m_provider->prepareRequest(
-        payload, promptTemplate, context, PluginLLMCore::RequestType::Chat, false, false);
-}
-
 bool ChatCompressor::createCompressedChatFile(
     const QString &sourcePath, const QString &destPath, const QString &summary)
 {
@@ -221,11 +232,11 @@ bool ChatCompressor::createCompressedChatFile(
 
     QJsonObject summaryMessage;
     summaryMessage["role"] = "assistant";
-    summaryMessage["content"] = QString("# Chat Summary\n\n%1").arg(summary);
     summaryMessage["id"] = QUuid::createUuid().toString(QUuid::WithoutBraces);
-    summaryMessage["isRedacted"] = false;
-    summaryMessage["attachments"] = QJsonArray();
-    summaryMessage["images"] = QJsonArray();
+    QJsonObject textBlock;
+    textBlock["type"] = "text";
+    textBlock["text"] = QString("# Chat Summary\n\n%1").arg(summary);
+    summaryMessage["blocks"] = QJsonArray{textBlock};
 
     root["messages"] = QJsonArray{summaryMessage};
     root["compressedFrom"] = sourcePath;
@@ -244,49 +255,17 @@ bool ChatCompressor::createCompressedChatFile(
     return true;
 }
 
-void ChatCompressor::connectProviderSignals()
-{
-    auto *c = m_provider->client();
-
-    m_connections.append(connect(
-        c,
-        &::LLMQore::BaseClient::chunkReceived,
-        this,
-        &ChatCompressor::onPartialResponseReceived,
-        Qt::UniqueConnection));
-
-    m_connections.append(connect(
-        c,
-        &::LLMQore::BaseClient::requestCompleted,
-        this,
-        &ChatCompressor::onFullResponseReceived,
-        Qt::UniqueConnection));
-
-    m_connections.append(connect(
-        c,
-        &::LLMQore::BaseClient::requestFailed,
-        this,
-        &ChatCompressor::onRequestFailed,
-        Qt::UniqueConnection));
-}
-
-void ChatCompressor::disconnectAllSignals()
-{
-    for (const auto &connection : std::as_const(m_connections))
-        disconnect(connection);
-    m_connections.clear();
-}
-
 void ChatCompressor::cleanupState()
 {
-    disconnectAllSignals();
+    Session *session = m_session;
 
     m_isCompressing = false;
     m_currentRequestId.clear();
     m_originalChatPath.clear();
-    m_accumulatedSummary.clear();
-    m_chatModel = nullptr;
-    m_provider = nullptr;
+    m_session = nullptr;
+
+    if (session && m_sessionManager)
+        m_sessionManager->release(session);
 }
 
 } // namespace QodeAssist::Chat

ChatView/ChatCompressor.hpp

@@ -1,22 +1,22 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
-#include <QJsonObject>
 #include <QList>
 #include <QObject>
+#include <QPointer>
 #include <QString>
 
-namespace QodeAssist::PluginLLMCore {
-class Provider;
-class PromptTemplate;
-} // namespace QodeAssist::PluginLLMCore
+namespace QodeAssist {
+class SessionManager;
+class Session;
+class ConversationHistory;
+}
 
 namespace QodeAssist::Chat {
 
-class ChatModel;
-
 class ChatCompressor : public QObject
 {
     Q_OBJECT
@@ -24,7 +24,10 @@ class ChatCompressor : public QObject
 public:
     explicit ChatCompressor(QObject *parent = nullptr);
 
-    void startCompression(const QString &chatFilePath, ChatModel *chatModel);
+    void setSessionManager(SessionManager *sessionManager);
+    void setActiveAgent(const QString &agentName);
+
+    void startCompression(const QString &chatFilePath, ConversationHistory *sourceHistory);
 
     bool isCompressing() const;
     void cancelCompression();
@@ -34,30 +37,23 @@ signals:
     void compressionCompleted(const QString &compressedChatPath);
     void compressionFailed(const QString &error);
 
-private slots:
-    void onPartialResponseReceived(const QString &requestId, const QString &partialText);
-    void onFullResponseReceived(const QString &requestId, const QString &fullText);
-    void onRequestFailed(const QString &requestId, const QString &error);
-
 private:
+    void onCompressionFinished(const QString &requestId);
+    void onCompressionFailed(const QString &requestId, const QString &error);
+
     QString createCompressedChatPath(const QString &originalPath) const;
     QString buildCompressionPrompt() const;
     bool createCompressedChatFile(
         const QString &sourcePath, const QString &destPath, const QString &summary);
-    void connectProviderSignals();
-    void disconnectAllSignals();
     void cleanupState();
     void handleCompressionError(const QString &error);
-    void buildRequestPayload(QJsonObject &payload, PluginLLMCore::PromptTemplate *promptTemplate);
 
     bool m_isCompressing = false;
     QString m_currentRequestId;
     QString m_originalChatPath;
-    QString m_accumulatedSummary;
-    PluginLLMCore::Provider *m_provider = nullptr;
-    ChatModel *m_chatModel = nullptr;
-
-    QList<QMetaObject::Connection> m_connections;
+    QPointer<SessionManager> m_sessionManager;
+    QString m_activeAgent;
+    QPointer<Session> m_session;
 };
 
 } // namespace QodeAssist::Chat

ChatView/ChatConfigurationController.cpp

@@ -1,99 +0,0 @@
-// Copyright (C) 2024-2026 Petr Mironychev
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "ChatConfigurationController.hpp"
-
-#include <utils/aspects.h>
-
-#include "ConfigurationManager.hpp"
-#include "GeneralSettings.hpp"
-
-namespace QodeAssist::Chat {
-
-ChatConfigurationController::ChatConfigurationController(QObject *parent)
-    : QObject(parent)
-{
-    auto &settings = Settings::generalSettings();
-    connect(
-        &settings.caProvider,
-        &Utils::BaseAspect::changed,
-        this,
-        &ChatConfigurationController::updateCurrentConfiguration);
-    connect(
-        &settings.caModel,
-        &Utils::BaseAspect::changed,
-        this,
-        &ChatConfigurationController::updateCurrentConfiguration);
-
-    loadAvailableConfigurations();
-}
-
-QStringList ChatConfigurationController::availableConfigurations() const
-{
-    return m_availableConfigurations;
-}
-
-QString ChatConfigurationController::currentConfiguration() const
-{
-    return m_currentConfiguration;
-}
-
-void ChatConfigurationController::updateCurrentConfiguration()
-{
-    auto &settings = Settings::generalSettings();
-    m_currentConfiguration
-        = QString("%1 - %2").arg(settings.caProvider.value(), settings.caModel.value());
-    emit currentConfigurationChanged();
-}
-
-void ChatConfigurationController::loadAvailableConfigurations()
-{
-    auto &manager = Settings::ConfigurationManager::instance();
-    manager.loadConfigurations(Settings::ConfigurationType::Chat);
-
-    QVector<Settings::AIConfiguration> configs = manager.configurations(
-        Settings::ConfigurationType::Chat);
-
-    m_availableConfigurations.clear();
-    m_availableConfigurations.append(QObject::tr("Current Settings"));
-
-    for (const Settings::AIConfiguration &config : configs) {
-        m_availableConfigurations.append(config.name);
-    }
-
-    updateCurrentConfiguration();
-
-    emit availableConfigurationsChanged();
-}
-
-void ChatConfigurationController::applyConfiguration(const QString &configName)
-{
-    if (configName == QObject::tr("Current Settings")) {
-        return;
-    }
-
-    auto &manager = Settings::ConfigurationManager::instance();
-    QVector<Settings::AIConfiguration> configs = manager.configurations(
-        Settings::ConfigurationType::Chat);
-
-    for (const Settings::AIConfiguration &config : configs) {
-        if (config.name == configName) {
-            auto &settings = Settings::generalSettings();
-
-            settings.caProvider.setValue(config.provider);
-            settings.caModel.setValue(config.model);
-            settings.caTemplate.setValue(config.templateName);
-            settings.caUrl.setValue(config.url);
-            settings.caCustomEndpoint.setValue(config.customEndpoint);
-
-            settings.writeSettings();
-
-            m_currentConfiguration = QString("%1 - %2").arg(config.provider, config.model);
-            emit currentConfigurationChanged();
-
-            break;
-        }
-    }
-}
-
-} // namespace QodeAssist::Chat

ChatView/ChatConfigurationController.hpp

@@ -1,35 +0,0 @@
-// Copyright (C) 2024-2026 Petr Mironychev
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <QObject>
-#include <QStringList>
-
-namespace QodeAssist::Chat {
-
-class ChatConfigurationController : public QObject
-{
-    Q_OBJECT
-
-public:
-    explicit ChatConfigurationController(QObject *parent = nullptr);
-
-    QStringList availableConfigurations() const;
-    QString currentConfiguration() const;
-
-    void loadAvailableConfigurations();
-    void applyConfiguration(const QString &configName);
-
-signals:
-    void availableConfigurationsChanged();
-    void currentConfigurationChanged();
-
-private:
-    void updateCurrentConfiguration();
-
-    QStringList m_availableConfigurations;
-    QString m_currentConfiguration;
-};
-
-} // namespace QodeAssist::Chat

ChatView/ChatData.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

ChatView/ChatFileManager.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "ChatFileManager.hpp"
 #include "Logger.hpp"

ChatView/ChatFileManager.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

ChatView/ChatHistoryStore.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "ChatHistoryStore.hpp"
 
@@ -15,15 +16,20 @@
 #include <projectexplorer/project.h>
 #include <projectexplorer/projectmanager.h>
 
-#include "ChatModel.hpp"
+#include <ConversationHistory.hpp>
+#include <Message.hpp>
+#include <PluginBlocks.hpp>
+
+#include <LLMQore/ContentBlocks.hpp>
+
 #include "Logger.hpp"
 #include "ProjectSettings.hpp"
 
 namespace QodeAssist::Chat {
 
-ChatHistoryStore::ChatHistoryStore(ChatModel *chatModel, QObject *parent)
+ChatHistoryStore::ChatHistoryStore(ConversationHistory *history, QObject *parent)
     : QObject(parent)
-    , m_chatModel(chatModel)
+    , m_history(history)
 {}
 
 QString ChatHistoryStore::historyDir() const
@@ -51,17 +57,23 @@ QString ChatHistoryStore::suggestedFileName() const
 {
     QString shortMessage;
 
-    if (m_chatModel->rowCount() > 0) {
-        QString firstMessage
-            = m_chatModel->data(m_chatModel->index(0), ChatModel::Content).toString();
-        shortMessage = firstMessage.split('\n').first().simplified().left(30);
+    if (m_history) {
+        for (const auto &message : m_history->messages()) {
+            if (message.role() != Message::Role::User)
+                continue;
 
-        if (shortMessage.isEmpty()) {
-            QVariantList images
-                = m_chatModel->data(m_chatModel->index(0), ChatModel::Images).toList();
-            if (!images.isEmpty()) {
-                shortMessage = "image_chat";
+            const QString text = message.text();
+            if (!text.trimmed().isEmpty()) {
+                shortMessage = text.split('\n').first().simplified().left(30);
+            } else {
+                for (const auto &block : message.blocks()) {
+                    if (dynamic_cast<StoredImageContent *>(block.get())) {
+                        shortMessage = "image_chat";
+                        break;
+                    }
+                }
             }
+            break;
         }
     }
 
@@ -106,12 +118,12 @@ QString ChatHistoryStore::autosaveFilePath(
 
 SerializationResult ChatHistoryStore::save(const QString &filePath) const
 {
-    return ChatSerializer::saveToFile(m_chatModel, filePath);
+    return ChatSerializer::saveToFile(m_history, filePath);
 }
 
 SerializationResult ChatHistoryStore::load(const QString &filePath) const
 {
-    return ChatSerializer::loadFromFile(m_chatModel, filePath);
+    return ChatSerializer::loadFromFile(m_history, filePath);
 }
 
 void ChatHistoryStore::showSaveDialog()

ChatView/ChatHistoryStore.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
@@ -8,16 +9,18 @@
 
 #include "ChatSerializer.hpp"
 
-namespace QodeAssist::Chat {
+namespace QodeAssist {
+class ConversationHistory;
+}
 
-class ChatModel;
+namespace QodeAssist::Chat {
 
 class ChatHistoryStore : public QObject
 {
     Q_OBJECT
 
 public:
-    explicit ChatHistoryStore(ChatModel *chatModel, QObject *parent = nullptr);
+    explicit ChatHistoryStore(ConversationHistory *history, QObject *parent = nullptr);
 
     QString historyDir() const;
     QString suggestedFileName() const;
@@ -41,7 +44,7 @@ signals:
 private:
     QString generateChatFileName(const QString &shortMessage, const QString &dir) const;
 
-    ChatModel *m_chatModel;
+    ConversationHistory *m_history;
 };
 
 } // namespace QodeAssist::Chat

ChatView/ChatModel.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
@@ -7,11 +8,16 @@
 #include "MessagePart.hpp"
 
 #include <QAbstractListModel>
+#include <QHash>
 #include <QJsonArray>
 #include <QJsonObject>
+#include <QPointer>
+#include <QVector>
 #include <QtQmlIntegration>
 
-#include "context/ContentFile.hpp"
+namespace QodeAssist {
+class ConversationHistory;
+}
 
 namespace QodeAssist::Chat {
 
@@ -42,81 +48,19 @@ public:
     };
     Q_ENUM(Roles)
 
-    struct ImageAttachment
-    {
-        QString fileName;      // Original filename
-        QString storedPath;    // Path to stored image file (relative to chat folder)
-        QString mediaType;     // MIME type
-    };
-
-    struct Message
-    {
-        ChatRole role;
-        QString content;
-        QString id;
-        bool isRedacted = false;
-        QString signature = QString();
-
-        QList<Context::ContentFile> attachments;
-        QList<ImageAttachment> images;
-
-        QString toolName;
-        QJsonObject toolArguments;
-        QString toolResult;
-
-        int promptTokens = 0;
-        int completionTokens = 0;
-        int cachedPromptTokens = 0;
-        int reasoningTokens = 0;
-    };
-
     explicit ChatModel(QObject *parent = nullptr);
 
+    void setHistory(ConversationHistory *history);
+
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
     QHash<int, QByteArray> roleNames() const override;
 
-    Q_INVOKABLE void addMessage(
-        const QString &content,
-        ChatRole role,
-        const QString &id,
-        const QList<Context::ContentFile> &attachments = {},
-        const QList<ImageAttachment> &images = {},
-        bool isRedacted = false,
-        const QString &signature = QString());
     Q_INVOKABLE void clear();
     Q_INVOKABLE QList<MessagePart> processMessageContent(const QString &content) const;
-
-    QVector<Message> getChatHistory() const;
-    QJsonArray prepareMessagesForRequest(const QString &systemPrompt) const;
-
-    QString currentModel() const;
-    QString lastMessageId() const;
-
     Q_INVOKABLE void resetModelTo(int index);
     Q_INVOKABLE QVariantList userMessagePreviews(int maxLength = 80) const;
 
-    void addToolExecutionStatus(
-        const QString &requestId,
-        const QString &toolId,
-        const QString &toolName,
-        const QJsonObject &toolArguments);
-    void dropTrailingAssistantMessage(const QString &requestId);
-    void setToolMessageData(
-        const QString &toolId,
-        const QString &toolName,
-        const QJsonObject &toolArguments,
-        const QString &toolResult);
-    void updateToolResult(
-        const QString &requestId,
-        const QString &toolId,
-        const QString &toolName,
-        const QString &result);
-    void addThinkingBlock(
-        const QString &requestId, const QString &thinking, const QString &signature);
-    void addRedactedThinkingBlock(const QString &requestId, const QString &signature);
-    void updateMessageContent(const QString &messageId, const QString &newContent);
-
     void setMessageUsage(
         const QString &messageId,
         int promptTokens,
@@ -128,10 +72,7 @@ public:
     int sessionCompletionTokens() const;
     int sessionCachedPromptTokens() const;
     int sessionTotalTokens() const;
-    
-    void setLoadingFromHistory(bool loading);
-    bool isLoadingFromHistory() const;
-    
+
     void setChatFilePath(const QString &filePath);
     QString chatFilePath() const;
 
@@ -140,18 +81,60 @@ signals:
     void sessionUsageChanged();
 
 private slots:
-    void onFileEditApplied(const QString &editId);
-    void onFileEditRejected(const QString &editId);
-    void onFileEditArchived(const QString &editId);
+    void onHistoryMessageAdded(int index);
+    void onHistoryMessageUpdated(int index);
+    void onHistoryCleared();
+    void onHistoryReset();
+    void onFileEditStatusChanged(const QString &editId);
 
 private:
-    void updateFileEditStatus(const QString &editId, const QString &status, const QString &statusMessage);
-    
-    QVector<Message> m_messages;
-    bool m_loadingFromHistory = false;
+    struct AttachmentRef
+    {
+        QString fileName;
+        QString storedPath;
+    };
+    struct ImageRef
+    {
+        QString fileName;
+        QString storedPath;
+        QString mediaType;
+    };
+    struct Row
+    {
+        ChatRole kind = ChatRole::Assistant;
+        int messageIndex = -1;
+        QString messageId;
+        QString content;
+        bool isRedacted = false;
+        QString editId;
+        QVector<AttachmentRef> attachments;
+        QVector<ImageRef> images;
+    };
+    struct Usage
+    {
+        int prompt = 0;
+        int completion = 0;
+        int cached = 0;
+        int reasoning = 0;
+    };
+
+    void rebuildAll();
+    void reprojectTail(int startMessageIndex);
+    int startMessageIndexFor(int messageIndex) const;
+    int firstRowForMessage(int messageIndex) const;
+    QHash<QString, QString> buildToolResultMap() const;
+    void appendRowsForMessage(
+        int messageIndex, const QHash<QString, QString> &toolResults, QVector<Row> &out) const;
+    QString overlayFileEditStatus(const QString &content, const QString &editId) const;
+    QVariantList buildAttachmentList(const QVector<AttachmentRef> &attachments) const;
+    QVariantList buildImageList(const QVector<ImageRef> &images) const;
+
+    QPointer<ConversationHistory> m_history;
+    QVector<Row> m_rows;
+    QHash<QString, Usage> m_usageByMessageId;
     QString m_chatFilePath;
 };
 
 } // namespace QodeAssist::Chat
-Q_DECLARE_METATYPE(QodeAssist::Chat::ChatModel::Message)
+
 Q_DECLARE_METATYPE(QodeAssist::Chat::MessagePart)

ChatView/ChatRootView.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "ChatRootView.hpp"
 
@@ -10,6 +11,7 @@
 #include <QFile>
 #include <QFileDialog>
 #include <QFileInfo>
+#include <QKeySequence>
 #include <QMessageBox>
 #include <QQmlContext>
 #include <QQmlEngine>
@@ -26,9 +28,16 @@
 
 #include "QodeAssistConstants.hpp"
 
-#include "AgentRoleController.hpp"
+#include <AgentFactory.hpp>
+#include <AgentRouter.hpp>
+#include <ConversationHistory.hpp>
+#include <Message.hpp>
+#include <SessionManager.hpp>
+#include <sources/settings/PipelinesConfig.hpp>
+
+#include "ChatAgentController.hpp"
+#include "AgentRole.hpp"
 #include "ChatAssistantSettings.hpp"
-#include "ChatConfigurationController.hpp"
 #include "ChatCompressor.hpp"
 #include "ChatHistoryStore.hpp"
 #include "FileEditController.hpp"
@@ -36,10 +45,8 @@
 #include "InputTokenCounter.hpp"
 #include "SettingsConstants.hpp"
 #include "Logger.hpp"
-#include "ProvidersManager.hpp"
 #include "SessionFileRegistry.hpp"
 #include "context/ContextManager.hpp"
-#include "pluginllmcore/RulesLoader.hpp"
 #include "ProjectSettings.hpp"
 #include "SkillsSettings.hpp"
 #include "sources/skills/SkillsManager.hpp"
@@ -52,23 +59,39 @@ bool isChatEditor(Core::IEditor *editor)
     return editor && editor->document()
            && editor->document()->id() == Utils::Id(Constants::QODE_ASSIST_CHAT_EDITOR_ID);
 }
+
+QKeySequence sendMessageKeySequence()
+{
+    auto command = Core::ActionManager::command(Constants::QODE_ASSIST_CHAT_SEND_MESSAGE);
+    if (!command)
+        return {};
+
+    QKeySequence sequence = command->keySequence();
+    if (sequence.isEmpty()) {
+        const QList<QKeySequence> defaults = command->defaultKeySequences();
+        if (!defaults.isEmpty())
+            sequence = defaults.constFirst();
+    }
+    return sequence;
+}
 } // namespace
 
 ChatRootView::ChatRootView(QQuickItem *parent)
     : QQuickItem(parent)
+    , m_history(new QodeAssist::ConversationHistory(this))
     , m_chatModel(new ChatModel(this))
-    , m_promptProvider(PluginLLMCore::PromptTemplateManager::instance())
-    , m_clientInterface(new ClientInterface(m_chatModel, &m_promptProvider, this))
+    , m_clientInterface(new ClientInterface(m_chatModel, this))
     , m_fileManager(new ChatFileManager(this))
     , m_isRequestInProgress(false)
     , m_chatCompressor(new ChatCompressor(this))
-    , m_agentRoleController(new AgentRoleController(this))
-    , m_configurationController(new ChatConfigurationController(this))
-    , m_fileEditController(new FileEditController(m_chatModel, this))
-    , m_tokenCounter(
-          new InputTokenCounter(m_chatModel, m_clientInterface->contextManager(), this))
-    , m_historyStore(new ChatHistoryStore(m_chatModel, this))
+    , m_agentController(new ChatAgentController(this))
+    , m_fileEditController(new FileEditController(this))
+    , m_tokenCounter(new InputTokenCounter(m_history, m_clientInterface->contextManager(), this))
+    , m_historyStore(new ChatHistoryStore(m_history, this))
 {
+    m_chatModel->setHistory(m_history);
+    m_clientInterface->setHistory(m_history);
+
     m_isSyncOpenFiles = Settings::chatAssistantSettings().linkOpenFiles();
     connect(
         &Settings::chatAssistantSettings().linkOpenFiles,
@@ -76,21 +99,21 @@ ChatRootView::ChatRootView(QQuickItem *parent)
         this,
         [this]() { setIsSyncOpenFiles(Settings::chatAssistantSettings().linkOpenFiles()); });
 
-    auto &settings = Settings::generalSettings();
-
-    connect(
-        &settings.caModel, &Utils::BaseAspect::changed, this, &ChatRootView::currentTemplateChanged);
-
-    connect(
-        m_configurationController,
-        &ChatConfigurationController::availableConfigurationsChanged,
+    QMetaObject::invokeMethod(
         this,
-        &ChatRootView::availableConfigurationsChanged);
-    connect(
-        m_configurationController,
-        &ChatConfigurationController::currentConfigurationChanged,
-        this,
-        &ChatRootView::currentConfigurationChanged);
+        [this] {
+            if (auto sendCommand
+                = Core::ActionManager::command(Constants::QODE_ASSIST_CHAT_SEND_MESSAGE)) {
+                connect(
+                    sendCommand,
+                    &Core::Command::keySequenceChanged,
+                    this,
+                    &ChatRootView::sendShortcutTextChanged,
+                    Qt::UniqueConnection);
+            }
+            emit sendShortcutTextChanged();
+        },
+        Qt::QueuedConnection);
 
     connect(
         m_clientInterface,
@@ -138,20 +161,30 @@ ChatRootView::ChatRootView(QQuickItem *parent)
         this,
         &ChatRootView::inputTokensCountChanged);
     connect(
-        m_agentRoleController,
-        &AgentRoleController::availableRolesChanged,
+        m_agentController,
+        &ChatAgentController::availableAgentsChanged,
         this,
-        &ChatRootView::availableAgentRolesChanged);
+        &ChatRootView::availableChatAgentsChanged);
     connect(
-        m_agentRoleController,
-        &AgentRoleController::currentRoleChanged,
+        m_agentController,
+        &ChatAgentController::currentAgentChanged,
         this,
-        &ChatRootView::currentAgentRoleChanged);
+        &ChatRootView::currentChatAgentChanged);
     connect(
-        m_agentRoleController,
-        &AgentRoleController::baseSystemPromptChanged,
+        m_agentController,
+        &ChatAgentController::currentAgentChanged,
         this,
-        &ChatRootView::baseSystemPromptChanged);
+        &ChatRootView::isThinkingSupportChanged);
+    connect(
+        m_agentController,
+        &ChatAgentController::currentAgentChanged,
+        this,
+        &ChatRootView::useToolsChanged);
+    connect(
+        m_agentController,
+        &ChatAgentController::currentAgentChanged,
+        this,
+        &ChatRootView::useThinkingChanged);
 
     auto editors = Core::EditorManager::instance();
 
@@ -233,14 +266,6 @@ ChatRootView::ChatRootView(QQuickItem *parent)
     connect(
         m_historyStore, &ChatHistoryStore::loadRequested, this, &ChatRootView::loadHistory);
 
-    refreshRules();
-
-    connect(
-        ProjectExplorer::ProjectManager::instance(),
-        &ProjectExplorer::ProjectManager::startupProjectChanged,
-        this,
-        &ChatRootView::refreshRules);
-
     connect(
         ProjectExplorer::ProjectManager::instance(),
         &ProjectExplorer::ProjectManager::projectAdded,
@@ -265,12 +290,6 @@ ChatRootView::ChatRootView(QQuickItem *parent)
         this,
         &ChatRootView::useThinkingChanged);
 
-    connect(
-        &Settings::generalSettings().caProvider,
-        &Utils::BaseAspect::changed,
-        this,
-        &ChatRootView::isThinkingSupportChanged);
-
     connect(m_fileManager, &ChatFileManager::fileOperationFailed, this, [this](const QString &error) {
         m_lastErrorMessage = error;
         emit lastErrorMessageChanged();
@@ -291,7 +310,7 @@ ChatRootView::ChatRootView(QQuickItem *parent)
         if (m_pendingSend.active) {
             PendingSend p = m_pendingSend;
             m_pendingSend = {};
-            dispatchSend(p.message, p.attachments, p.linkedFiles, p.useTools, p.useThinking);
+            dispatchSend(p.message, p.attachments, p.linkedFiles);
         }
     });
 
@@ -304,7 +323,7 @@ ChatRootView::ChatRootView(QQuickItem *parent)
         if (m_pendingSend.active) {
             PendingSend p = m_pendingSend;
             m_pendingSend = {};
-            dispatchSend(p.message, p.attachments, p.linkedFiles, p.useTools, p.useThinking);
+            dispatchSend(p.message, p.attachments, p.linkedFiles);
         }
     });
 }
@@ -340,6 +359,85 @@ Skills::SkillsManager *ChatRootView::skillsManager() const
     return m_skillsManager;
 }
 
+AgentFactory *ChatRootView::agentFactory() const
+{
+    if (!m_agentFactory) {
+        if (auto *engine = qmlEngine(this)) {
+            m_agentFactory = qobject_cast<AgentFactory *>(
+                engine->rootContext()->contextProperty("agentFactory").value<QObject *>());
+        }
+    }
+    return m_agentFactory;
+}
+
+SessionManager *ChatRootView::sessionManager() const
+{
+    if (!m_sessionManager) {
+        if (auto *engine = qmlEngine(this)) {
+            m_sessionManager = qobject_cast<SessionManager *>(
+                engine->rootContext()->contextProperty("sessionManager").value<QObject *>());
+        }
+    }
+    return m_sessionManager;
+}
+
+void ChatRootView::loadAvailableChatAgents()
+{
+    m_agentController->setAgentFactory(agentFactory());
+}
+
+QStringList ChatRootView::availableChatAgents() const
+{
+    return m_agentController->availableAgents();
+}
+
+QString ChatRootView::currentChatAgent() const
+{
+    return m_agentController->currentAgent();
+}
+
+void ChatRootView::setCurrentChatAgent(const QString &name)
+{
+    m_agentController->setCurrentAgent(name);
+}
+
+QStringList ChatRootView::availableRoles() const
+{
+    return m_availableRoles;
+}
+
+QString ChatRootView::currentRole() const
+{
+    return m_currentRole;
+}
+
+void ChatRootView::setCurrentRole(const QString &roleId)
+{
+    if (m_currentRole == roleId)
+        return;
+    m_currentRole = roleId;
+    emit currentRoleChanged();
+}
+
+void ChatRootView::loadAvailableRoles()
+{
+    QStringList ids;
+    const QList<Settings::AgentRole> roles = Settings::AgentRolesManager::loadAllRoles();
+    ids.reserve(roles.size());
+    for (const auto &r : roles)
+        ids << r.id;
+
+    if (ids != m_availableRoles) {
+        m_availableRoles = ids;
+        emit availableRolesChanged();
+    }
+
+    if (!m_availableRoles.isEmpty() && !m_availableRoles.contains(m_currentRole))
+        setCurrentRole(m_availableRoles.contains(QStringLiteral("developer"))
+                           ? QStringLiteral("developer")
+                           : m_availableRoles.first());
+}
+
 QVariantList ChatRootView::searchSkills(const QString &query) const
 {
     QVariantList results;
@@ -347,7 +445,7 @@ QVariantList ChatRootView::searchSkills(const QString &query) const
     if (!manager || !Settings::skillsSettings().enableSkills())
         return results;
 
-    auto *project = PluginLLMCore::RulesLoader::getActiveProject();
+    auto *project = ProjectExplorer::ProjectManager::startupProject();
     QStringList projectSkillDirs;
     if (project) {
         Settings::ProjectSettings projectSettings(project);
@@ -383,21 +481,17 @@ void ChatRootView::sendMessage(const QString &message)
 {
     const QStringList attachments = m_attachmentFiles;
     const QStringList linkedFiles = m_linkedFiles;
-    const bool tools = useTools();
-    const bool thinking = useThinking();
 
-    if (deferSendForAutoCompress(message, attachments, linkedFiles, tools, thinking))
+    if (deferSendForAutoCompress(message, attachments, linkedFiles))
         return;
 
-    dispatchSend(message, attachments, linkedFiles, tools, thinking);
+    dispatchSend(message, attachments, linkedFiles);
 }
 
 bool ChatRootView::deferSendForAutoCompress(
     const QString &message,
     const QStringList &attachments,
-    const QStringList &linkedFiles,
-    bool useToolsArg,
-    bool useThinkingArg)
+    const QStringList &linkedFiles)
 {
     auto &settings = Settings::chatAssistantSettings();
     if (!settings.autoCompress())
@@ -423,7 +517,7 @@ bool ChatRootView::deferSendForAutoCompress(
                     .arg(inputTokens)
                     .arg(threshold));
 
-    m_pendingSend = {message, attachments, linkedFiles, useToolsArg, useThinkingArg, true};
+    m_pendingSend = {message, attachments, linkedFiles, true};
     compressCurrentChat();
     return true;
 }
@@ -431,9 +525,7 @@ bool ChatRootView::deferSendForAutoCompress(
 void ChatRootView::dispatchSend(
     const QString &message,
     const QStringList &attachments,
-    const QStringList &linkedFiles,
-    bool useToolsArg,
-    bool useThinkingArg)
+    const QStringList &linkedFiles)
 {
     if (m_recentFilePath.isEmpty()) {
         QString filePath = getAutosaveFilePath(message, attachments);
@@ -448,8 +540,14 @@ void ChatRootView::dispatchSend(
 
     m_tokenCounter->recordSent();
 
+    if (currentChatAgent().isEmpty())
+        loadAvailableChatAgents();
+
     m_clientInterface->setSkillsManager(skillsManager());
-    m_clientInterface->sendMessage(message, attachments, linkedFiles, useToolsArg, useThinkingArg);
+    m_clientInterface->setSessionManager(sessionManager());
+    m_clientInterface->setActiveAgent(currentChatAgent());
+    m_clientInterface->setActiveRole(currentRole());
+    m_clientInterface->sendMessage(message, attachments, linkedFiles);
 
     m_fileManager->clearIntermediateStorage();
     clearAttachmentFiles();
@@ -494,12 +592,6 @@ void ChatRootView::clearMessages()
     clearLinkedFiles();
 }
 
-QString ChatRootView::currentTemplate() const
-{
-    auto &settings = Settings::generalSettings();
-    return settings.caModel();
-}
-
 void ChatRootView::saveHistory(const QString &filePath)
 {
     if (filePath != m_recentFilePath) {
@@ -743,6 +835,32 @@ void ChatRootView::calculateMessageTokensCount(const QString &message)
     m_tokenCounter->setMessage(message);
 }
 
+bool ChatRootView::isSendShortcut(int key, int modifiers) const
+{
+    const QKeySequence sequence = sendMessageKeySequence();
+    if (sequence.isEmpty())
+        return false;
+
+    const QKeyCombination combination = sequence[0];
+    const int sequenceKey = combination.key();
+
+    const int relevantMask = Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier
+                             | Qt::MetaModifier;
+    const int sequenceModifiers = combination.keyboardModifiers() & relevantMask;
+    const int eventModifiers = modifiers & relevantMask;
+
+    const bool isReturnLike = sequenceKey == Qt::Key_Return || sequenceKey == Qt::Key_Enter;
+    const bool keyMatches = key == sequenceKey
+        || (isReturnLike && (key == Qt::Key_Return || key == Qt::Key_Enter));
+
+    return keyMatches && eventModifiers == sequenceModifiers;
+}
+
+QString ChatRootView::sendShortcutText() const
+{
+    return sendMessageKeySequence().toString(QKeySequence::NativeText);
+}
+
 void ChatRootView::setIsSyncOpenFiles(bool state)
 {
     if (m_isSyncOpenFiles != state) {
@@ -762,25 +880,6 @@ void ChatRootView::openChatHistoryFolder()
     m_historyStore->openHistoryFolder();
 }
 
-void ChatRootView::openRulesFolder()
-{
-    auto project = ProjectExplorer::ProjectManager::startupProject();
-    if (!project) {
-        return;
-    }
-
-    QString projectPath = project->projectDirectory().toFSPathString();
-    QString rulesPath = QDir(projectPath).filePath(".qodeassist/rules");
-
-    QDir dir(rulesPath);
-    if (!dir.exists()) {
-        dir.mkpath(".");
-    }
-
-    QUrl url = QUrl::fromLocalFile(dir.absolutePath());
-    QDesktopServices::openUrl(url);
-}
-
 void ChatRootView::openSettings()
 {
     QMetaObject::invokeMethod(
@@ -831,13 +930,12 @@ QString ChatRootView::chatTitle() const
 
 QString ChatRootView::computeChatTitle() const
 {
-    if (!m_chatModel)
+    if (!m_history)
         return {};
-    const auto history = m_chatModel->getChatHistory();
-    for (const auto &msg : history) {
-        if (msg.role != ChatModel::User)
+    for (const auto &msg : m_history->messages()) {
+        if (msg.role() != Message::Role::User)
             continue;
-        const QString content = msg.content.trimmed();
+        const QString content = msg.text().trimmed();
         if (content.isEmpty())
             continue;
         const QString firstLine = content.section(QChar('\n'), 0, 0).trimmed();
@@ -1005,11 +1103,7 @@ void ChatRootView::setRecentFilePath(const QString &filePath)
 
 bool ChatRootView::shouldIgnoreFileForAttach(const Utils::FilePath &filePath)
 {
-    auto project = ProjectExplorer::ProjectManager::projectForFile(filePath);
-    if (project
-        && m_clientInterface->contextManager()
-               ->ignoreManager()
-               ->shouldIgnore(filePath.toFSPathString(), project)) {
+    if (m_clientInterface->contextManager()->shouldIgnore(filePath.toFSPathString())) {
         LOG_MESSAGE(QString("Ignoring file for attachment due to .qodeassistignore: %1")
                         .arg(filePath.toFSPathString()));
         return true;
@@ -1061,71 +1155,14 @@ QString ChatRootView::lastErrorMessage() const
     return m_lastErrorMessage;
 }
 
-QVariantList ChatRootView::activeRules() const
-{
-    return m_activeRules;
-}
-
-int ChatRootView::activeRulesCount() const
-{
-    return m_activeRules.size();
-}
-
-QString ChatRootView::getRuleContent(int index)
-{
-    if (index < 0 || index >= m_activeRules.size())
-        return QString();
-
-    return PluginLLMCore::RulesLoader::loadRuleFileContent(
-        m_activeRules[index].toMap()["filePath"].toString());
-}
-
-void ChatRootView::refreshRules()
-{
-    m_activeRules.clear();
-
-    auto project = PluginLLMCore::RulesLoader::getActiveProject();
-    if (!project) {
-        emit activeRulesChanged();
-        emit activeRulesCountChanged();
-        return;
-    }
-
-    auto ruleFiles
-        = PluginLLMCore::RulesLoader::getRuleFilesForProject(project, PluginLLMCore::RulesContext::Chat);
-
-    for (const auto &ruleFile : ruleFiles) {
-        QVariantMap ruleMap;
-        ruleMap["filePath"] = ruleFile.filePath;
-        ruleMap["fileName"] = ruleFile.fileName;
-        ruleMap["category"] = ruleFile.category;
-        m_activeRules.append(ruleMap);
-    }
-
-    emit activeRulesChanged();
-    emit activeRulesCountChanged();
-}
-
 bool ChatRootView::useTools() const
 {
-    return Settings::chatAssistantSettings().enableChatTools();
-}
-
-void ChatRootView::setUseTools(bool enabled)
-{
-    Settings::chatAssistantSettings().enableChatTools.setValue(enabled);
-    Settings::chatAssistantSettings().writeSettings();
+    return m_agentController->currentSupportsTools();
 }
 
 bool ChatRootView::useThinking() const
 {
-    return Settings::chatAssistantSettings().enableThinkingMode();
-}
-
-void ChatRootView::setUseThinking(bool enabled)
-{
-    Settings::chatAssistantSettings().enableThinkingMode.setValue(enabled);
-    Settings::chatAssistantSettings().writeSettings();
+    return m_agentController->currentSupportsThinking();
 }
 
 void ChatRootView::applyFileEdit(const QString &editId)
@@ -1190,10 +1227,7 @@ QString ChatRootView::lastInfoMessage() const
 
 bool ChatRootView::isThinkingSupport() const
 {
-    auto providerName = Settings::generalSettings().caProvider();
-    auto provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
-
-    return provider && provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::Thinking);
+    return m_agentController->currentSupportsThinking();
 }
 
 bool ChatRootView::hasImageAttachments(const QStringList &attachments) const
@@ -1214,66 +1248,6 @@ bool ChatRootView::isImageFile(const QString &filePath) const
     return imageExtensions.contains(fileInfo.suffix().toLower());
 }
 
-void ChatRootView::loadAvailableConfigurations()
-{
-    m_configurationController->loadAvailableConfigurations();
-}
-
-void ChatRootView::applyConfiguration(const QString &configName)
-{
-    m_configurationController->applyConfiguration(configName);
-}
-
-QStringList ChatRootView::availableConfigurations() const
-{
-    return m_configurationController->availableConfigurations();
-}
-
-QString ChatRootView::currentConfiguration() const
-{
-    return m_configurationController->currentConfiguration();
-}
-
-void ChatRootView::loadAvailableAgentRoles()
-{
-    m_agentRoleController->loadAvailableRoles();
-}
-
-void ChatRootView::applyAgentRole(const QString &roleName)
-{
-    m_agentRoleController->applyRole(roleName);
-}
-
-QStringList ChatRootView::availableAgentRoles() const
-{
-    return m_agentRoleController->availableRoles();
-}
-
-QString ChatRootView::currentAgentRole() const
-{
-    return m_agentRoleController->currentRole();
-}
-
-QString ChatRootView::baseSystemPrompt() const
-{
-    return m_agentRoleController->baseSystemPrompt();
-}
-
-QString ChatRootView::currentAgentRoleDescription() const
-{
-    return m_agentRoleController->currentRoleDescription();
-}
-
-QString ChatRootView::currentAgentRoleSystemPrompt() const
-{
-    return m_agentRoleController->currentRoleSystemPrompt();
-}
-
-void ChatRootView::openAgentRolesSettings()
-{
-    m_agentRoleController->openSettings();
-}
-
 void ChatRootView::compressCurrentChat()
 {
     if (m_chatCompressor->isCompressing()) {
@@ -1290,7 +1264,20 @@ void ChatRootView::compressCurrentChat()
 
     autosave();
 
-    m_chatCompressor->startCompression(m_recentFilePath, m_chatModel);
+    if (currentChatAgent().isEmpty())
+        loadAvailableChatAgents();
+    m_chatCompressor->setSessionManager(sessionManager());
+
+    QString compressionAgent = currentChatAgent();
+    const QStringList roster = Settings::PipelinesConfig::load().rosters.chatCompression;
+    if (!roster.isEmpty() && agentFactory()) {
+        const QString picked
+            = AgentRouter::pickAgent(roster, AgentRouter::Context{}, *agentFactory());
+        if (!picked.isEmpty())
+            compressionAgent = picked;
+    }
+    m_chatCompressor->setActiveAgent(compressionAgent);
+    m_chatCompressor->startCompression(m_recentFilePath, m_history);
 }
 
 void ChatRootView::cancelCompression()

ChatView/ChatRootView.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
@@ -10,18 +11,22 @@
 #include "ChatFileManager.hpp"
 #include "ChatModel.hpp"
 #include "ClientInterface.hpp"
-#include "pluginllmcore/PromptProviderChat.hpp"
 #include <coreplugin/editormanager/editormanager.h>
 
 namespace QodeAssist::Skills {
 class SkillsManager;
 }
 
+namespace QodeAssist {
+class AgentFactory;
+class SessionManager;
+class ConversationHistory;
+}
+
 namespace QodeAssist::Chat {
 
 class ChatCompressor;
-class AgentRoleController;
-class ChatConfigurationController;
+class ChatAgentController;
 class FileEditController;
 class InputTokenCounter;
 class ChatHistoryStore;
@@ -31,7 +36,6 @@ class ChatRootView : public QQuickItem
 {
     Q_OBJECT
     Q_PROPERTY(QodeAssist::Chat::ChatModel *chatModel READ chatModel NOTIFY chatModelChanged FINAL)
-    Q_PROPERTY(QString currentTemplate READ currentTemplate NOTIFY currentTemplateChanged FINAL)
     Q_PROPERTY(bool isSyncOpenFiles READ isSyncOpenFiles NOTIFY isSyncOpenFilesChanged FINAL)
     Q_PROPERTY(QStringList attachmentFiles READ attachmentFiles NOTIFY attachmentFilesChanged FINAL)
     Q_PROPERTY(QStringList linkedFiles READ linkedFiles NOTIFY linkedFilesChanged FINAL)
@@ -45,23 +49,19 @@ class ChatRootView : public QQuickItem
     Q_PROPERTY(bool isRequestInProgress READ isRequestInProgress NOTIFY isRequestInProgressChanged FINAL)
     Q_PROPERTY(QString lastErrorMessage READ lastErrorMessage NOTIFY lastErrorMessageChanged FINAL)
     Q_PROPERTY(QString lastInfoMessage READ lastInfoMessage NOTIFY lastInfoMessageChanged FINAL)
-    Q_PROPERTY(QVariantList activeRules READ activeRules NOTIFY activeRulesChanged FINAL)
-    Q_PROPERTY(int activeRulesCount READ activeRulesCount NOTIFY activeRulesCountChanged FINAL)
-    Q_PROPERTY(bool useTools READ useTools WRITE setUseTools NOTIFY useToolsChanged FINAL)
-    Q_PROPERTY(bool useThinking READ useThinking WRITE setUseThinking NOTIFY useThinkingChanged FINAL)
+    Q_PROPERTY(bool useTools READ useTools NOTIFY useToolsChanged FINAL)
+    Q_PROPERTY(bool useThinking READ useThinking NOTIFY useThinkingChanged FINAL)
+    Q_PROPERTY(QString sendShortcutText READ sendShortcutText NOTIFY sendShortcutTextChanged FINAL)
     
     Q_PROPERTY(int currentMessageTotalEdits READ currentMessageTotalEdits NOTIFY currentMessageEditsStatsChanged FINAL)
     Q_PROPERTY(int currentMessageAppliedEdits READ currentMessageAppliedEdits NOTIFY currentMessageEditsStatsChanged FINAL)
     Q_PROPERTY(int currentMessagePendingEdits READ currentMessagePendingEdits NOTIFY currentMessageEditsStatsChanged FINAL)
     Q_PROPERTY(int currentMessageRejectedEdits READ currentMessageRejectedEdits NOTIFY currentMessageEditsStatsChanged FINAL)
     Q_PROPERTY(bool isThinkingSupport READ isThinkingSupport NOTIFY isThinkingSupportChanged FINAL)
-    Q_PROPERTY(QStringList availableConfigurations READ availableConfigurations NOTIFY availableConfigurationsChanged FINAL)
-    Q_PROPERTY(QString currentConfiguration READ currentConfiguration NOTIFY currentConfigurationChanged FINAL)
-    Q_PROPERTY(QStringList availableAgentRoles READ availableAgentRoles NOTIFY availableAgentRolesChanged FINAL)
-    Q_PROPERTY(QString currentAgentRole READ currentAgentRole NOTIFY currentAgentRoleChanged FINAL)
-    Q_PROPERTY(QString baseSystemPrompt READ baseSystemPrompt NOTIFY baseSystemPromptChanged FINAL)
-    Q_PROPERTY(QString currentAgentRoleDescription READ currentAgentRoleDescription NOTIFY currentAgentRoleChanged FINAL)
-    Q_PROPERTY(QString currentAgentRoleSystemPrompt READ currentAgentRoleSystemPrompt NOTIFY currentAgentRoleChanged FINAL)
+    Q_PROPERTY(QStringList availableChatAgents READ availableChatAgents NOTIFY availableChatAgentsChanged FINAL)
+    Q_PROPERTY(QString currentChatAgent READ currentChatAgent WRITE setCurrentChatAgent NOTIFY currentChatAgentChanged FINAL)
+    Q_PROPERTY(QStringList availableRoles READ availableRoles NOTIFY availableRolesChanged FINAL)
+    Q_PROPERTY(QString currentRole READ currentRole WRITE setCurrentRole NOTIFY currentRoleChanged FINAL)
     Q_PROPERTY(bool isCompressing READ isCompressing NOTIFY isCompressingChanged FINAL)
     Q_PROPERTY(bool isInEditor READ isInEditor NOTIFY isInEditorChanged FINAL)
     Q_PROPERTY(QString chatTitle READ chatTitle NOTIFY chatTitleChanged FINAL)
@@ -73,7 +73,6 @@ public:
     ~ChatRootView() override;
 
     ChatModel *chatModel() const;
-    QString currentTemplate() const;
 
     void saveHistory(const QString &filePath);
     void loadHistory(const QString &filePath);
@@ -98,9 +97,10 @@ public:
     Q_INVOKABLE void showAddImageDialog();
     Q_INVOKABLE bool isImageFile(const QString &filePath) const;
     Q_INVOKABLE void calculateMessageTokensCount(const QString &message);
+    Q_INVOKABLE bool isSendShortcut(int key, int modifiers) const;
+    QString sendShortcutText() const;
     Q_INVOKABLE void setIsSyncOpenFiles(bool state);
     Q_INVOKABLE void openChatHistoryFolder();
-    Q_INVOKABLE void openRulesFolder();
     Q_INVOKABLE void openSettings();
 
     Q_INVOKABLE void openFileInEditor(const QString &filePath);
@@ -135,18 +135,11 @@ public:
     void setRequestProgressStatus(bool state);
 
     QString lastErrorMessage() const;
-    
-    QVariantList activeRules() const;
-    int activeRulesCount() const;
-    Q_INVOKABLE QString getRuleContent(int index);
-    Q_INVOKABLE void refreshRules();
 
     Q_INVOKABLE QVariantList searchSkills(const QString &query) const;
 
     bool useTools() const;
-    void setUseTools(bool enabled);
     bool useThinking() const;
-    void setUseThinking(bool enabled);
 
     Q_INVOKABLE void applyFileEdit(const QString &editId);
     Q_INVOKABLE void rejectFileEdit(const QString &editId);
@@ -157,23 +150,19 @@ public:
     Q_INVOKABLE void undoAllFileEditsForCurrentMessage();
     Q_INVOKABLE void updateCurrentMessageEditsStats();
 
-    Q_INVOKABLE void loadAvailableConfigurations();
-    Q_INVOKABLE void applyConfiguration(const QString &configName);
-    QStringList availableConfigurations() const;
-    QString currentConfiguration() const;
-
     Q_INVOKABLE void compressCurrentChat();
     Q_INVOKABLE void cancelCompression();
 
-    Q_INVOKABLE void loadAvailableAgentRoles();
-    Q_INVOKABLE void applyAgentRole(const QString &roleId);
-    Q_INVOKABLE void openAgentRolesSettings();
-    QStringList availableAgentRoles() const;
-    QString currentAgentRole() const;
-    QString baseSystemPrompt() const;
-    QString currentAgentRoleDescription() const;
-    QString currentAgentRoleSystemPrompt() const;
-    
+    Q_INVOKABLE void loadAvailableChatAgents();
+    QStringList availableChatAgents() const;
+    QString currentChatAgent() const;
+    void setCurrentChatAgent(const QString &name);
+
+    Q_INVOKABLE void loadAvailableRoles();
+    QStringList availableRoles() const;
+    QString currentRole() const;
+    void setCurrentRole(const QString &roleId);
+
     int currentMessageTotalEdits() const;
     int currentMessageAppliedEdits() const;
     int currentMessagePendingEdits() const;
@@ -202,7 +191,6 @@ public slots:
 
 signals:
     void chatModelChanged();
-    void currentTemplateChanged();
     void attachmentFilesChanged();
     void linkedFilesChanged();
     void inputTokensCountChanged();
@@ -218,20 +206,18 @@ signals:
 
     void lastErrorMessageChanged();
     void lastInfoMessageChanged();
-    void activeRulesChanged();
-    void activeRulesCountChanged();
+    void sendShortcutTextChanged();
 
     void useToolsChanged();
     void useThinkingChanged();
     void currentMessageEditsStatsChanged();
 
     void isThinkingSupportChanged();
-    void availableConfigurationsChanged();
-    void currentConfigurationChanged();
 
-    void availableAgentRolesChanged();
-    void currentAgentRoleChanged();
-    void baseSystemPromptChanged();
+    void availableChatAgentsChanged();
+    void currentChatAgentChanged();
+    void availableRolesChanged();
+    void currentRoleChanged();
 
     void isCompressingChanged();
     void compressionCompleted(const QString &compressedChatPath);
@@ -251,25 +237,22 @@ private:
     bool deferSendForAutoCompress(
         const QString &message,
         const QStringList &attachments,
-        const QStringList &linkedFiles,
-        bool useTools,
-        bool useThinking);
+        const QStringList &linkedFiles);
     void dispatchSend(
         const QString &message,
         const QStringList &attachments,
-        const QStringList &linkedFiles,
-        bool useTools,
-        bool useThinking);
+        const QStringList &linkedFiles);
     bool hasImageAttachments(const QStringList &attachments) const;
 
     SessionFileRegistry *sessionFileRegistry() const;
     Skills::SkillsManager *skillsManager() const;
+    AgentFactory *agentFactory() const;
+    SessionManager *sessionManager() const;
 
+    QodeAssist::ConversationHistory *m_history;
     ChatModel *m_chatModel;
-    PluginLLMCore::PromptProviderChat m_promptProvider;
     ClientInterface *m_clientInterface;
     ChatFileManager *m_fileManager;
-    QString m_currentTemplate;
     QString m_recentFilePath;
     QStringList m_attachmentFiles;
     QStringList m_linkedFiles;
@@ -278,8 +261,6 @@ private:
         QString message;
         QStringList attachments;
         QStringList linkedFiles;
-        bool useTools = false;
-        bool useThinking = false;
         bool active = false;
     };
     PendingSend m_pendingSend;
@@ -289,13 +270,14 @@ private:
     QList<Core::IEditor *> m_currentEditors;
     bool m_isRequestInProgress;
     QString m_lastErrorMessage;
-    QVariantList m_activeRules;
-    
+
     QString m_lastInfoMessage;
 
+    QString m_currentRole = QStringLiteral("developer");
+    QStringList m_availableRoles;
+
     ChatCompressor *m_chatCompressor;
-    AgentRoleController *m_agentRoleController;
-    ChatConfigurationController *m_configurationController;
+    ChatAgentController *m_agentController;
     FileEditController *m_fileEditController;
     InputTokenCounter *m_tokenCounter;
     ChatHistoryStore *m_historyStore;
@@ -303,6 +285,8 @@ private:
     mutable bool m_sessionFileRegistryResolved = false;
     mutable QPointer<Skills::SkillsManager> m_skillsManager;
     mutable bool m_skillsManagerResolved = false;
+    mutable QPointer<AgentFactory> m_agentFactory;
+    mutable QPointer<SessionManager> m_sessionManager;
 };
 
 } // namespace QodeAssist::Chat

ChatView/ChatSerializer.cpp

@@ -1,10 +1,12 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "ChatSerializer.hpp"
 #include "Logger.hpp"
 
-#include <QBuffer>
+#include <memory>
+
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
@@ -12,12 +14,57 @@
 #include <QJsonDocument>
 #include <QUuid>
 
+#include <LLMQore/ContentBlocks.hpp>
+
+#include <ConversationHistory.hpp>
+#include <Message.hpp>
+#include <MessageSerializer.hpp>
+#include <PluginBlocks.hpp>
+
+#include "context/ChangesManager.h"
+
 namespace QodeAssist::Chat {
 
-const QString ChatSerializer::VERSION = "0.2";
+namespace {
 
-SerializationResult ChatSerializer::saveToFile(const ChatModel *model, const QString &filePath)
+const QString kFileEditMarker = QStringLiteral("QODEASSIST_FILE_EDIT:");
+
+// Legacy (<= 0.2) per-row ChatRole values, kept only for importing old chat files.
+enum class LegacyRole { System = 0, User = 1, Assistant = 2, Tool = 3, FileEdit = 4, Thinking = 5 };
+
+void registerEditFromResult(const QString &result)
 {
+    const int pos = result.indexOf(kFileEditMarker);
+    if (pos < 0)
+        return;
+    const QString jsonStr = result.mid(pos + kFileEditMarker.length());
+    const QJsonDocument doc = QJsonDocument::fromJson(jsonStr.toUtf8());
+    if (!doc.isObject())
+        return;
+    const QJsonObject obj = doc.object();
+    const QString editId = obj.value("edit_id").toString();
+    const QString filePath = obj.value("file").toString();
+    if (editId.isEmpty() || filePath.isEmpty())
+        return;
+    Context::ChangesManager::instance().addFileEdit(
+        editId,
+        filePath,
+        obj.value("old_content").toString(),
+        obj.value("new_content").toString(),
+        /*autoApply=*/false,
+        /*isFromHistory=*/true);
+}
+
+} // namespace
+
+const QString ChatSerializer::VERSION = "0.3";
+
+SerializationResult ChatSerializer::saveToFile(
+    const ConversationHistory *history, const QString &filePath)
+{
+    if (!history)
+        return {false, "No conversation history"};
+
     if (!ensureDirectoryExists(filePath)) {
         return {false, "Failed to create directory structure"};
     }
@@ -27,9 +74,7 @@ SerializationResult ChatSerializer::saveToFile(const ChatModel *model, const QSt
         return {false, QString("Failed to open file for writing: %1").arg(filePath)};
     }
 
-    QJsonObject root = serializeChat(model, filePath);
-    QJsonDocument doc(root);
-
+    QJsonDocument doc(serializeChat(history));
     if (file.write(doc.toJson(QJsonDocument::Indented)) == -1) {
         return {false, QString("Failed to write to file: %1").arg(file.errorString())};
     }
@@ -37,8 +82,12 @@ SerializationResult ChatSerializer::saveToFile(const ChatModel *model, const QSt
     return {true, QString()};
 }
 
-SerializationResult ChatSerializer::loadFromFile(ChatModel *model, const QString &filePath)
+SerializationResult ChatSerializer::loadFromFile(
+    ConversationHistory *history, const QString &filePath)
 {
+    if (!history)
+        return {false, "No conversation history"};
+
     QFile file(filePath);
     if (!file.open(QIODevice::ReadOnly)) {
         return {false, QString("Failed to open file for reading: %1").arg(filePath)};
@@ -50,180 +99,140 @@ SerializationResult ChatSerializer::loadFromFile(ChatModel *model, const QString
         return {false, QString("JSON parse error: %1").arg(error.errorString())};
     }
 
-    QJsonObject root = doc.object();
-    QString version = root["version"].toString();
-
+    const QJsonObject root = doc.object();
+    const QString version = root["version"].toString();
     if (!validateVersion(version)) {
         return {false, QString("Unsupported version: %1").arg(version)};
     }
 
-    if (!deserializeChat(model, root, filePath)) {
-        return {false, "Failed to deserialize chat data"};
-    }
-
-    return {true, QString()};
+    if (version == VERSION)
+        return loadCurrent(history, root);
+    return loadLegacy(history, root);
 }
 
-QJsonObject ChatSerializer::serializeMessage(
-    const ChatModel::Message &message, const QString &chatFilePath)
-{
-    QJsonObject messageObj;
-    messageObj["role"] = static_cast<int>(message.role);
-    messageObj["content"] = message.content;
-    messageObj["id"] = message.id;
-
-    if (message.isRedacted) {
-        messageObj["isRedacted"] = true;
-    }
-
-    if (!message.signature.isEmpty()) {
-        messageObj["signature"] = message.signature;
-    }
-
-    if (message.role == ChatModel::ChatRole::Tool) {
-        if (!message.toolName.isEmpty())
-            messageObj["toolName"] = message.toolName;
-        if (!message.toolArguments.isEmpty())
-            messageObj["toolArguments"] = message.toolArguments;
-        if (!message.toolResult.isEmpty())
-            messageObj["toolResult"] = message.toolResult;
-    }
-
-    if (!message.attachments.isEmpty()) {
-        QJsonArray attachmentsArray;
-        for (const auto &attachment : message.attachments) {
-            QJsonObject attachmentObj;
-            attachmentObj["fileName"] = attachment.filename;
-            attachmentObj["storedPath"] = attachment.content;
-            attachmentsArray.append(attachmentObj);
-        }
-        messageObj["attachments"] = attachmentsArray;
-    }
-
-    if (!message.images.isEmpty()) {
-        QJsonArray imagesArray;
-        for (const auto &image : message.images) {
-            QJsonObject imageObj;
-            imageObj["fileName"] = image.fileName;
-            imageObj["storedPath"] = image.storedPath;
-            imageObj["mediaType"] = image.mediaType;
-            imagesArray.append(imageObj);
-        }
-        messageObj["images"] = imagesArray;
-    }
-
-    if (message.promptTokens > 0 || message.completionTokens > 0) {
-        QJsonObject usageObj;
-        usageObj["promptTokens"] = message.promptTokens;
-        usageObj["completionTokens"] = message.completionTokens;
-        if (message.cachedPromptTokens > 0)
-            usageObj["cachedPromptTokens"] = message.cachedPromptTokens;
-        if (message.reasoningTokens > 0)
-            usageObj["reasoningTokens"] = message.reasoningTokens;
-        messageObj["usage"] = usageObj;
-    }
-
-    return messageObj;
-}
-
-ChatModel::Message ChatSerializer::deserializeMessage(
-    const QJsonObject &json, const QString &chatFilePath)
-{
-    ChatModel::Message message;
-    message.role = static_cast<ChatModel::ChatRole>(json["role"].toInt());
-    message.content = json["content"].toString();
-    message.id = json["id"].toString();
-    message.isRedacted = json["isRedacted"].toBool(false);
-    message.signature = json["signature"].toString();
-    message.toolName = json["toolName"].toString();
-    message.toolArguments = json["toolArguments"].toObject();
-    message.toolResult = json["toolResult"].toString();
-
-    if (json.contains("attachments")) {
-        QJsonArray attachmentsArray = json["attachments"].toArray();
-        for (const auto &attachmentValue : attachmentsArray) {
-            QJsonObject attachmentObj = attachmentValue.toObject();
-            Context::ContentFile attachment;
-            attachment.filename = attachmentObj["fileName"].toString();
-            attachment.content = attachmentObj["storedPath"].toString();
-            message.attachments.append(attachment);
-        }
-    }
-
-    if (json.contains("images")) {
-        QJsonArray imagesArray = json["images"].toArray();
-        for (const auto &imageValue : imagesArray) {
-            QJsonObject imageObj = imageValue.toObject();
-            ChatModel::ImageAttachment image;
-            image.fileName = imageObj["fileName"].toString();
-            image.storedPath = imageObj["storedPath"].toString();
-            image.mediaType = imageObj["mediaType"].toString();
-            message.images.append(image);
-        }
-    }
-
-    if (json.contains("usage")) {
-        const QJsonObject usageObj = json["usage"].toObject();
-        message.promptTokens = usageObj["promptTokens"].toInt();
-        message.completionTokens = usageObj["completionTokens"].toInt();
-        message.cachedPromptTokens = usageObj["cachedPromptTokens"].toInt();
-        message.reasoningTokens = usageObj["reasoningTokens"].toInt();
-    }
-
-    return message;
-}
-
-QJsonObject ChatSerializer::serializeChat(const ChatModel *model, const QString &chatFilePath)
+QJsonObject ChatSerializer::serializeChat(const ConversationHistory *history)
 {
     QJsonArray messagesArray;
-    for (const auto &message : model->getChatHistory()) {
-        messagesArray.append(serializeMessage(message, chatFilePath));
-    }
+    for (const auto &message : history->messages())
+        messagesArray.append(MessageSerializer::toJson(message));
 
     QJsonObject root;
     root["version"] = VERSION;
     root["messages"] = messagesArray;
-
     return root;
 }
 
-bool ChatSerializer::deserializeChat(
-    ChatModel *model, const QJsonObject &json, const QString &chatFilePath)
+SerializationResult ChatSerializer::loadCurrent(ConversationHistory *history, const QJsonObject &root)
 {
-    QJsonArray messagesArray = json["messages"].toArray();
-    QVector<ChatModel::Message> messages;
-    messages.reserve(messagesArray.size());
+    history->clear();
 
-    for (const auto &messageValue : messagesArray) {
-        messages.append(deserializeMessage(messageValue.toObject(), chatFilePath));
+    const QJsonArray messagesArray = root["messages"].toArray();
+    for (const auto &value : messagesArray) {
+        bool ok = false;
+        Message message = MessageSerializer::fromJson(value.toObject(), &ok);
+        if (ok)
+            history->append(std::move(message));
     }
 
-    model->clear();
+    registerHistoricalFileEdits(history);
+    return {true, QString()};
+}
 
-    model->setLoadingFromHistory(true);
+SerializationResult ChatSerializer::loadLegacy(ConversationHistory *history, const QJsonObject &root)
+{
+    history->clear();
 
-    for (const auto &message : messages) {
-        model->addMessage(
-            message.content,
-            message.role,
-            message.id,
-            message.attachments,
-            message.images,
-            message.isRedacted,
-            message.signature);
-        if (message.role == ChatModel::ChatRole::Tool) {
-            model->setToolMessageData(
-                message.id, message.toolName, message.toolArguments, message.toolResult);
+    const QJsonArray arr = root["messages"].toArray();
+    int i = 0;
+    while (i < arr.size()) {
+        const QJsonObject mj = arr[i].toObject();
+        const auto role = static_cast<LegacyRole>(mj["role"].toInt());
+
+        if (role == LegacyRole::Tool) {
+            Message assistant(Message::Role::Assistant);
+            Message toolResults(Message::Role::User);
+            while (i < arr.size()
+                   && static_cast<LegacyRole>(arr[i].toObject()["role"].toInt()) == LegacyRole::Tool) {
+                const QJsonObject tj = arr[i].toObject();
+                const QString toolName = tj["toolName"].toString();
+                const QString id = tj["id"].toString();
+                if (!toolName.isEmpty()) {
+                    assistant.appendBlock(std::make_unique<LLMQore::ToolUseContent>(
+                        id, toolName, tj["toolArguments"].toObject()));
+                    toolResults.appendBlock(std::make_unique<LLMQore::ToolResultContent>(
+                        id, tj["toolResult"].toString()));
+                }
+                ++i;
+            }
+            if (!assistant.blocks().empty()) {
+                history->append(std::move(assistant));
+                history->append(std::move(toolResults));
+            }
+            continue;
+        }
+
+        ++i;
+
+        if (role == LegacyRole::FileEdit)
+            continue; // derived from the tool result in the new model
+
+        if (role == LegacyRole::Thinking) {
+            const QString content = mj["content"].toString();
+            const QString signature = mj["signature"].toString();
+            Message assistant(Message::Role::Assistant);
+            if (mj["isRedacted"].toBool(false)) {
+                assistant.appendBlock(
+                    std::make_unique<LLMQore::RedactedThinkingContent>(signature));
+            } else {
+                const int sigPos = content.indexOf(QStringLiteral("\n[Signature:"));
+                const QString thinking = sigPos >= 0 ? content.left(sigPos) : content;
+                assistant.appendBlock(
+                    std::make_unique<LLMQore::ThinkingContent>(thinking, signature));
+            }
+            history->append(std::move(assistant));
+            continue;
+        }
+
+        if (role == LegacyRole::User) {
+            Message user(Message::Role::User, mj["id"].toString());
+            user.appendBlock(std::make_unique<LLMQore::TextContent>(mj["content"].toString()));
+            for (const auto &a : mj["attachments"].toArray()) {
+                const QJsonObject ao = a.toObject();
+                user.appendBlock(std::make_unique<StoredAttachmentContent>(
+                    ao["fileName"].toString(), ao["storedPath"].toString()));
+            }
+            for (const auto &im : mj["images"].toArray()) {
+                const QJsonObject io = im.toObject();
+                user.appendBlock(std::make_unique<StoredImageContent>(
+                    io["fileName"].toString(),
+                    io["storedPath"].toString(),
+                    io["mediaType"].toString()));
+            }
+            history->append(std::move(user));
+        } else {
+            const QString content = mj["content"].toString();
+            if (content.trimmed().isEmpty())
+                continue;
+            const Message::Role mapped
+                = role == LegacyRole::System ? Message::Role::System : Message::Role::Assistant;
+            Message message(mapped, mj["id"].toString());
+            message.appendBlock(std::make_unique<LLMQore::TextContent>(content));
+            history->append(std::move(message));
         }
-        LOG_MESSAGE(QString("Loaded message with %1 image(s), isRedacted=%2, signature length=%3")
-                        .arg(message.images.size())
-                        .arg(message.isRedacted)
-                        .arg(message.signature.length()));
     }
 
-    model->setLoadingFromHistory(false);
+    registerHistoricalFileEdits(history);
+    return {true, QString()};
+}
 
-    return true;
+void ChatSerializer::registerHistoricalFileEdits(const ConversationHistory *history)
+{
+    for (const auto &message : history->messages()) {
+        for (const auto &block : message.blocks()) {
+            if (auto *tr = dynamic_cast<LLMQore::ToolResultContent *>(block.get()))
+                registerEditFromResult(tr->result());
+        }
+    }
 }
 
 bool ChatSerializer::ensureDirectoryExists(const QString &filePath)
@@ -235,18 +244,7 @@ bool ChatSerializer::ensureDirectoryExists(const QString &filePath)
 
 bool ChatSerializer::validateVersion(const QString &version)
 {
-    if (version == VERSION) {
-        return true;
-    }
-
-    if (version == "0.1") {
-        LOG_MESSAGE(
-            "Loading chat from old format 0.1 - images folder structure has changed from _images "
-            "to _content");
-        return true;
-    }
-
-    return false;
+    return version == VERSION || version == "0.2" || version == "0.1";
 }
 
 QString ChatSerializer::getChatContentFolder(const QString &chatFilePath)

ChatView/ChatSerializer.hpp

@@ -1,13 +1,15 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
-#include <QJsonArray>
 #include <QJsonObject>
 #include <QString>
 
-#include "ChatModel.hpp"
+namespace QodeAssist {
+class ConversationHistory;
+}
 
 namespace QodeAssist::Chat {
 
@@ -20,26 +22,26 @@ struct SerializationResult
 class ChatSerializer
 {
 public:
-    static SerializationResult saveToFile(const ChatModel *model, const QString &filePath);
-    static SerializationResult loadFromFile(ChatModel *model, const QString &filePath);
-
-    // Public for testing purposes
-    static QJsonObject serializeMessage(const ChatModel::Message &message, const QString &chatFilePath);
-    static ChatModel::Message deserializeMessage(const QJsonObject &json, const QString &chatFilePath);
-    static QJsonObject serializeChat(const ChatModel *model, const QString &chatFilePath);
-    static bool deserializeChat(ChatModel *model, const QJsonObject &json, const QString &chatFilePath);
+    static SerializationResult saveToFile(
+        const ConversationHistory *history, const QString &filePath);
+    static SerializationResult loadFromFile(ConversationHistory *history, const QString &filePath);
 
     // Content management (images and text files)
     static QString getChatContentFolder(const QString &chatFilePath);
-    static bool saveContentToStorage(const QString &chatFilePath, 
-                                      const QString &fileName,
-                                      const QString &base64Data,
-                                      QString &storedPath);
+    static bool saveContentToStorage(
+        const QString &chatFilePath,
+        const QString &fileName,
+        const QString &base64Data,
+        QString &storedPath);
     static QString loadContentFromStorage(const QString &chatFilePath, const QString &storedPath);
 
 private:
     static const QString VERSION;
-    static constexpr int CURRENT_VERSION = 1;
+
+    static QJsonObject serializeChat(const ConversationHistory *history);
+    static SerializationResult loadCurrent(ConversationHistory *history, const QJsonObject &root);
+    static SerializationResult loadLegacy(ConversationHistory *history, const QJsonObject &root);
+    static void registerHistoricalFileEdits(const ConversationHistory *history);
 
     static bool ensureDirectoryExists(const QString &filePath);
     static bool validateVersion(const QString &version);

ChatView/ChatUtils.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "ChatUtils.h"
 

ChatView/ChatUtils.h

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

ChatView/ChatView.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "ChatView.hpp"
 

ChatView/ChatView.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

ChatView/ChatWidget.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "ChatWidget.hpp"
 

ChatView/ChatWidget.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

ChatView/ClientInterface.cpp

@@ -1,75 +1,107 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "ClientInterface.hpp"
 
-#include <LLMQore/BaseClient.hpp>
+#include <memory>
+#include <vector>
 
+#include <LLMQore/BaseClient.hpp>
+#include <LLMQore/ContentBlocks.hpp>
+#include <LLMQore/ToolsManager.hpp>
+
+#include <coreplugin/editormanager/editormanager.h>
+#include <coreplugin/editormanager/ieditor.h>
+#include <coreplugin/idocument.h>
 #include <projectexplorer/buildconfiguration.h>
+#include <projectexplorer/project.h>
+#include <projectexplorer/projectmanager.h>
 #include <projectexplorer/target.h>
 #include <texteditor/textdocument.h>
+#include <texteditor/texteditor.h>
+
+#include <QDir>
 #include <QFile>
 #include <QFileInfo>
-#include <QImageReader>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QMimeDatabase>
 #include <QRegularExpression>
 #include <QUuid>
 
-#include <coreplugin/editormanager/editormanager.h>
-#include <coreplugin/editormanager/ieditor.h>
-#include <coreplugin/idocument.h>
-#include <projectexplorer/project.h>
-#include <projectexplorer/projectexplorer.h>
-#include <projectexplorer/projectmanager.h>
-
-#include <texteditor/textdocument.h>
-#include <texteditor/texteditor.h>
-
-#include <LLMQore/ToolsManager.hpp>
+#include <ConversationHistory.hpp>
+#include <ContextRenderer.hpp>
+#include <Message.hpp>
+#include <PluginBlocks.hpp>
+#include <Session.hpp>
+#include <SessionManager.hpp>
+#include <SystemPromptBuilder.hpp>
 
 #include "tools/ReadOriginalHistoryTool.hpp"
 #include "tools/TodoTool.hpp"
+#include "tools/ToolsRegistration.hpp"
 
-#include "ChatAssistantSettings.hpp"
 #include "ChatSerializer.hpp"
 #include "GeneralSettings.hpp"
 #include "Logger.hpp"
 #include "ProjectSettings.hpp"
-#include "ProvidersManager.hpp"
 #include "SkillsSettings.hpp"
 #include "ToolsSettings.hpp"
-#include <RulesLoader.hpp>
 #include <context/ChangesManager.h>
 #include <sources/skills/SkillsManager.hpp>
 
 namespace QodeAssist::Chat {
 
-ClientInterface::ClientInterface(
-    ChatModel *chatModel, PluginLLMCore::IPromptProvider *promptProvider, QObject *parent)
+namespace {
+struct StoredImage
+{
+    QString fileName;
+    QString storedPath;
+    QString mediaType;
+};
+} // namespace
+
+ClientInterface::ClientInterface(ChatModel *chatModel, QObject *parent)
     : QObject(parent)
-    , m_promptProvider(promptProvider)
     , m_chatModel(chatModel)
     , m_contextManager(new Context::ContextManager(this))
 {}
 
-void ClientInterface::setSkillsManager(Skills::SkillsManager *skillsManager)
-{
-    m_skillsManager = skillsManager;
-}
-
 ClientInterface::~ClientInterface()
 {
     cancelRequest();
 }
 
+void ClientInterface::setSkillsManager(Skills::SkillsManager *skillsManager)
+{
+    m_skillsManager = skillsManager;
+}
+
+void ClientInterface::setSessionManager(SessionManager *sessionManager)
+{
+    m_sessionManager = sessionManager;
+}
+
+void ClientInterface::setHistory(ConversationHistory *history)
+{
+    m_history = history;
+}
+
+void ClientInterface::setActiveAgent(const QString &agentName)
+{
+    m_activeAgent = agentName;
+}
+
+void ClientInterface::setActiveRole(const QString &roleId)
+{
+    m_activeRoleId = roleId;
+}
+
 void ClientInterface::sendMessage(
     const QString &message,
     const QList<QString> &attachments,
-    const QList<QString> &linkedFiles,
-    bool useTools,
-    bool useThinking)
+    const QList<QString> &linkedFiles)
 {
     if (message.trimmed().isEmpty() && attachments.isEmpty()) {
         LOG_MESSAGE("Ignoring empty chat message");
@@ -77,19 +109,16 @@ void ClientInterface::sendMessage(
     }
 
     cancelRequest();
-    m_accumulatedResponses.clear();
 
     Context::ChangesManager::instance().archiveAllNonArchivedEdits();
 
     QList<QString> imageFiles;
     QList<QString> textFiles;
-
     for (const QString &filePath : attachments) {
-        if (isImageFile(filePath)) {
+        if (isImageFile(filePath))
             imageFiles.append(filePath);
-        } else {
+        else
             textFiles.append(filePath);
-        }
     }
 
     QList<Context::ContentFile> storedAttachments;
@@ -111,24 +140,19 @@ void ClientInterface::sendMessage(
                         .arg(textFiles.size()));
     }
 
-    QList<ChatModel::ImageAttachment> imageAttachments;
+    QList<StoredImage> storedImages;
     if (!imageFiles.isEmpty() && !m_chatFilePath.isEmpty()) {
         for (const QString &imagePath : imageFiles) {
             QString base64Data = encodeImageToBase64(imagePath);
-            if (base64Data.isEmpty()) {
+            if (base64Data.isEmpty())
                 continue;
-            }
 
             QString storedPath;
             QFileInfo fileInfo(imagePath);
             if (ChatSerializer::saveContentToStorage(
                     m_chatFilePath, fileInfo.fileName(), base64Data, storedPath)) {
-                ChatModel::ImageAttachment imageAttachment;
-                imageAttachment.fileName = fileInfo.fileName();
-                imageAttachment.storedPath = storedPath;
-                imageAttachment.mediaType = getMediaTypeForImage(imagePath);
-                imageAttachments.append(imageAttachment);
-
+                storedImages.append(
+                    {fileInfo.fileName(), storedPath, getMediaTypeForImage(imagePath)});
                 LOG_MESSAGE(QString("Stored image %1 as %2").arg(fileInfo.fileName(), storedPath));
             }
         }
@@ -137,325 +161,287 @@ void ClientInterface::sendMessage(
                         .arg(imageFiles.size()));
     }
 
-    m_chatModel->addMessage(message, ChatModel::ChatRole::User, "", storedAttachments, imageAttachments);
-
-    auto &chatAssistantSettings = Settings::chatAssistantSettings();
-
-    auto providerName = Settings::generalSettings().caProvider();
-    auto provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
-
-    if (!provider) {
-        LOG_MESSAGE(QString("No provider found with name: %1").arg(providerName));
+    if (!m_sessionManager) {
+        const QString error = QStringLiteral("Chat session manager is not available");
+        LOG_MESSAGE(error);
+        emit errorOccurred(error);
+        return;
+    }
+    if (!m_history) {
+        const QString error = QStringLiteral("Chat history is not available");
+        LOG_MESSAGE(error);
+        emit errorOccurred(error);
         return;
     }
 
-    auto templateName = Settings::generalSettings().caTemplate();
-    auto promptTemplate = m_promptProvider->getTemplateByName(templateName);
-
-    if (!promptTemplate) {
-        LOG_MESSAGE(QString("No template found with name: %1").arg(templateName));
+    QString sessionError;
+    Session *session = m_sessionManager->createSession(m_activeAgent, m_history, &sessionError);
+    if (!session) {
+        const QString error = sessionError.isEmpty()
+                                  ? QStringLiteral("No chat agent selected")
+                                  : sessionError;
+        LOG_MESSAGE(error);
+        emit errorOccurred(error);
         return;
     }
 
-    PluginLLMCore::ContextData context;
-
-    const bool isToolsEnabled = useTools;
-
-    if (chatAssistantSettings.useSystemPrompt()) {
-        QString systemPrompt = chatAssistantSettings.systemPrompt();
-
-        const QString lastRoleId = chatAssistantSettings.lastUsedRoleId();
-        if (!lastRoleId.isEmpty()) {
-            const Settings::AgentRole role = Settings::AgentRolesManager::loadRole(lastRoleId);
-            if (!role.id.isEmpty())
-                systemPrompt = systemPrompt + "\n\n" + role.systemPrompt;
-        }
-
-        auto project = PluginLLMCore::RulesLoader::getActiveProject();
-
-        if (project) {
-            systemPrompt += QString("\n# Active project: %1").arg(project->displayName());
-            systemPrompt += QString(
-                                "\n# Project source root: %1"
-                                "\n#   All new source files, headers, QML and CMake edits MUST be "
-                                "created or modified under this directory. Use absolute paths "
-                                "rooted here, or project-relative paths.")
-                                .arg(project->projectDirectory().toUrlishString());
-
-            if (auto target = project->activeTarget()) {
-                if (auto buildConfig = target->activeBuildConfiguration()) {
-                    systemPrompt
-                        += QString(
-                               "\n# Build output directory (compiler artifacts only — do NOT "
-                               "create or edit source files here): %1")
-                               .arg(buildConfig->buildDirectory().toUrlishString());
-                }
-            }
-
-            QString projectRules
-                = PluginLLMCore::RulesLoader::loadRulesForProject(project, PluginLLMCore::RulesContext::Chat);
-
-            if (!projectRules.isEmpty()) {
-                systemPrompt += QString("\n# Project Rules\n\n") + projectRules;
-            }
-        } else {
-            systemPrompt += QString("\n# No active project in IDE");
-        }
-
-        if (m_skillsManager && Settings::skillsSettings().enableSkills()) {
-            QStringList projectSkillDirs;
-            if (project) {
-                Settings::ProjectSettings projectSettings(project);
-                projectSkillDirs = Settings::SkillsSettings::splitLines(
-                    projectSettings.projectSkillDirs());
-            }
-            m_skillsManager->configure(
-                project ? project->projectDirectory().toFSPathString() : QString(),
-                Settings::SkillsSettings::splitPaths(
-                    Settings::skillsSettings().globalSkillRoots()),
-                projectSkillDirs);
-
-            const QString alwaysOnSkills = m_skillsManager->alwaysOnBodies();
-            if (!alwaysOnSkills.isEmpty())
-                systemPrompt += QString("\n\n") + alwaysOnSkills;
-
-            const QString skillsCatalog = m_skillsManager->catalogText();
-            if (!skillsCatalog.isEmpty())
-                systemPrompt += QString("\n\n") + skillsCatalog;
-
-            static const QRegularExpression skillCommand(
-                QStringLiteral("(?:^|\\s)/([a-z0-9][a-z0-9-]*)"));
-            QStringList invokedSkillNames;
-            auto skillMatch = skillCommand.globalMatch(message);
-            while (skillMatch.hasNext()) {
-                const QString skillName = skillMatch.next().captured(1);
-                if (invokedSkillNames.contains(skillName))
-                    continue;
-                const auto invokedSkill = m_skillsManager->findByName(skillName);
-                if (invokedSkill && !invokedSkill->body.isEmpty()) {
-                    invokedSkillNames << skillName;
-                    systemPrompt += QString("\n\n# Invoked Skill: %1\n\n%2")
-                                        .arg(invokedSkill->name, invokedSkill->body);
-                }
-            }
-        }
-
-        if (!linkedFiles.isEmpty()) {
-            systemPrompt = getSystemPromptWithLinkedFiles(systemPrompt, linkedFiles);
-        }
-        context.systemPrompt = systemPrompt;
+    auto *client = session->client();
+    if (!client) {
+        const QString error = QStringLiteral("Chat agent has no live client");
+        LOG_MESSAGE(error);
+        m_sessionManager->removeSession(session);
+        emit errorOccurred(error);
+        return;
     }
 
-    const bool toolHistory = promptTemplate->supportsToolHistory();
+    auto *project = ProjectExplorer::ProjectManager::startupProject();
+    Templates::ContextRenderer::Bindings bindings;
+    bindings.projectDir = project ? project->projectDirectory().toFSPathString() : QString();
+    bindings.homeDir = QDir::homePath();
+    bindings.roleId = m_activeRoleId;
+    session->setContextBindings(bindings);
 
-    QVector<PluginLLMCore::Message> messages;
-    int toolCallMsgIdx = -1;
-    for (const auto &msg : m_chatModel->getChatHistory()) {
-        if (msg.role == ChatModel::ChatRole::Tool) {
-            if (!toolHistory || msg.toolName.isEmpty()) {
-                continue;
-            }
+    const QString chatFilePath = m_chatFilePath;
+    session->setContentLoader([chatFilePath](const QString &storedPath) {
+        return ChatSerializer::loadContentFromStorage(chatFilePath, storedPath);
+    });
 
-            if (toolCallMsgIdx < 0) {
-                PluginLLMCore::Message assistantCall;
-                assistantCall.role = "assistant";
-                messages.append(assistantCall);
-                toolCallMsgIdx = messages.size() - 1;
-            }
+    m_sessionManager->toolContributors().contribute(client->tools());
+    client->setMaxToolContinuations(Settings::toolsSettings().maxToolContinuations());
+    client->setTransferTimeout(
+        static_cast<int>(Settings::generalSettings().requestTimeout() * 1000));
 
-            PluginLLMCore::ToolCall call;
-            call.id = msg.id;
-            call.name = msg.toolName;
-            call.arguments = msg.toolArguments;
-            messages[toolCallMsgIdx].toolCalls.append(call);
+    const QString chatContext = buildChatContextLayer(message, linkedFiles);
+    if (!chatContext.isEmpty())
+        session->systemPrompt()->setLayer(QStringLiteral("chat.context"), chatContext);
 
-            PluginLLMCore::Message toolResult;
-            toolResult.role = "tool";
-            toolResult.toolCallId = msg.id;
-            toolResult.toolName = msg.toolName;
-            toolResult.content = msg.toolResult;
-            messages.append(toolResult);
-            continue;
-        }
+    std::vector<std::unique_ptr<LLMQore::ContentBlock>> blocks;
+    blocks.push_back(std::make_unique<LLMQore::TextContent>(message));
 
-        toolCallMsgIdx = -1;
-
-        if (msg.role == ChatModel::ChatRole::FileEdit) {
-            continue;
-        }
-
-        PluginLLMCore::Message apiMessage;
-        apiMessage.role = msg.role == ChatModel::ChatRole::User ? "user" : "assistant";
-        apiMessage.content = msg.content;
-
-        if (!msg.attachments.isEmpty() && !m_chatFilePath.isEmpty()) {
-            apiMessage.content += "\n\nAttached files:";
-            for (const auto &attachment : msg.attachments) {
-                QString fileContent = ChatSerializer::loadContentFromStorage(m_chatFilePath, attachment.content);
-                if (!fileContent.isEmpty()) {
-                    QString decodedContent = QString::fromUtf8(QByteArray::fromBase64(fileContent.toUtf8()));
-                    apiMessage.content += QString("\n\nFile: %1\n```\n%2\n```")
-                                              .arg(attachment.filename, decodedContent);
-                }
-            }
-        }
-
-        apiMessage.isThinking = (msg.role == ChatModel::ChatRole::Thinking);
-        apiMessage.isRedacted = msg.isRedacted;
-        apiMessage.signature = msg.signature;
-
-        if (provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::Image)
-            && !m_chatFilePath.isEmpty() && !msg.images.isEmpty()) {
-            auto apiImages = loadImagesFromStorage(msg.images);
-            if (!apiImages.isEmpty()) {
-                apiMessage.images = apiImages;
-            }
-        }
-
-        messages.append(apiMessage);
+    for (const auto &attachment : storedAttachments) {
+        blocks.push_back(
+            std::make_unique<StoredAttachmentContent>(attachment.filename, attachment.content));
     }
 
-    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())));
+    if (!storedImages.isEmpty() && session->supportsImages()) {
+        for (const auto &image : storedImages) {
+            blocks.push_back(std::make_unique<StoredImageContent>(
+                image.fileName, image.storedPath, image.mediaType));
+        }
+    } else if (!storedImages.isEmpty() && !session->supportsImages()) {
+        LOG_MESSAGE(QString("Agent '%1' doesn't support images, %2 ignored")
+                        .arg(m_activeAgent)
+                        .arg(storedImages.size()));
     }
 
-    context.history = messages;
-
-    QJsonObject payload{
-        {"model", Settings::generalSettings().caModel()}, {"stream", true}};
-
-    provider->prepareRequest(
-        payload,
-        promptTemplate,
-        context,
-        PluginLLMCore::RequestType::Chat,
-        useTools,
-        useThinking);
-
-    provider->client()->setMaxToolContinuations(
-        Settings::toolsSettings().maxToolContinuations());
-
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::chunkReceived,
-        this,
-        &ClientInterface::handlePartialResponse,
-        Qt::UniqueConnection);
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::requestCompleted,
-        this,
-        &ClientInterface::handleFullResponse,
-        Qt::UniqueConnection);
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::requestFinalized,
-        this,
-        &ClientInterface::handleRequestFinalized,
-        Qt::UniqueConnection);
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::requestFailed,
-        this,
-        &ClientInterface::handleRequestFailed,
-        Qt::UniqueConnection);
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::toolStarted,
-        this,
-        &ClientInterface::handleToolExecutionStarted,
-        Qt::UniqueConnection);
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::toolResultReady,
-        this,
-        &ClientInterface::handleToolExecutionCompleted,
-        Qt::UniqueConnection);
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::thinkingBlockReceived,
-        this,
-        &ClientInterface::handleThinkingBlockReceived,
-        Qt::UniqueConnection);
-
-    const QString customEndpoint = Settings::generalSettings().caCustomEndpoint();
-    const QString endpoint = !customEndpoint.isEmpty() ? customEndpoint
-                                                       : promptTemplate->endpoint();
-    auto requestId
-        = provider->sendRequest(QUrl(Settings::generalSettings().caUrl()), payload, endpoint);
-    QJsonObject request{{"id", requestId}};
-
-    m_activeRequests[requestId] = {request, provider, !toolHistory};
-
-    emit requestStarted(requestId);
-    
-    if (provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::Tools)
-        && provider->toolsManager()) {
-        if (auto *todoTool = qobject_cast<QodeAssist::Tools::TodoTool *>(
-                provider->toolsManager()->tool("todo_tool"))) {
+    if (!m_chatFilePath.isEmpty()) {
+        if (auto *todoTool
+            = qobject_cast<QodeAssist::Tools::TodoTool *>(client->tools()->tool("todo_tool"))) {
             todoTool->setCurrentSessionId(m_chatFilePath);
         }
         if (auto *historyTool = qobject_cast<QodeAssist::Tools::ReadOriginalHistoryTool *>(
-                provider->toolsManager()->tool("read_original_history"))) {
+                client->tools()->tool("read_original_history"))) {
             historyTool->setCurrentSessionId(m_chatFilePath);
         }
     }
+
+    connect(session, &Session::event, this, [this, session](const QodeAssist::ResponseEvent &ev) {
+        onSessionEvent(session, ev);
+    });
+    connect(
+        session, &Session::finished, this,
+        [this](const LLMQore::RequestID &id, const QString &) { onSessionFinished(id); });
+    connect(
+        session, &Session::failed, this,
+        [this](const LLMQore::RequestID &id, const QodeAssist::ErrorInfo &error) {
+            onSessionFailed(id, error);
+        });
+
+    const LLMQore::RequestID requestId = session->send(std::move(blocks));
+    if (requestId.isEmpty()) {
+        const QString error = QStringLiteral("Failed to start chat request for agent '%1': %2")
+                                  .arg(m_activeAgent, session->lastError().message);
+        LOG_MESSAGE(error);
+        m_sessionManager->removeSession(session);
+        emit errorOccurred(error);
+        return;
+    }
+
+    m_activeRequests[requestId] = {QJsonObject{{"id", requestId}}, session};
+
+    emit requestStarted(requestId);
+}
+
+QString ClientInterface::requestIdForSession(Session *session) const
+{
+    for (auto it = m_activeRequests.cbegin(); it != m_activeRequests.cend(); ++it) {
+        if (it.value().session == session)
+            return it.key();
+    }
+    return {};
+}
+
+void ClientInterface::onSessionEvent(Session *session, const QodeAssist::ResponseEvent &ev)
+{
+    if (ev.kind() != ResponseEvent::Kind::Usage)
+        return;
+
+    const auto *usage = ev.as<ResponseEvents::Usage>();
+    if (!usage)
+        return;
+
+    const QString requestId = requestIdForSession(session);
+    if (!requestId.isEmpty()) {
+        m_chatModel->setMessageUsage(
+            requestId,
+            usage->inputTokens,
+            usage->outputTokens,
+            usage->cachedTokens,
+            usage->reasoningTokens);
+    }
+
+    emit messageUsageReceived(
+        usage->inputTokens, usage->outputTokens, usage->cachedTokens, usage->reasoningTokens);
+
+    LOG_MESSAGE(QString("Chat usage [%1]: prompt=%2 completion=%3 cached=%4 reasoning=%5")
+                    .arg(requestId)
+                    .arg(usage->inputTokens)
+                    .arg(usage->outputTokens)
+                    .arg(usage->cachedTokens)
+                    .arg(usage->reasoningTokens));
+}
+
+void ClientInterface::onSessionFinished(const QString &requestId)
+{
+    auto it = m_activeRequests.find(requestId);
+    if (it == m_activeRequests.end())
+        return;
+
+    Session *session = it.value().session;
+
+    QString applyError;
+    if (!Context::ChangesManager::instance().applyPendingEditsForRequest(requestId, &applyError)) {
+        LOG_MESSAGE(QString("Some edits for request %1 were not auto-applied: %2")
+                        .arg(requestId, applyError));
+    }
+
+    emit messageReceivedCompletely();
+
+    m_activeRequests.erase(it);
+
+    if (session && m_sessionManager)
+        m_sessionManager->removeSession(session);
+}
+
+void ClientInterface::onSessionFailed(const QString &requestId, const QodeAssist::ErrorInfo &error)
+{
+    auto it = m_activeRequests.find(requestId);
+    if (it == m_activeRequests.end())
+        return;
+
+    Session *session = it.value().session;
+
+    LOG_MESSAGE(QString("Chat request %1 failed: %2").arg(requestId, error.message));
+    emit errorOccurred(error.message);
+
+    m_activeRequests.erase(it);
+
+    if (session && m_sessionManager)
+        m_sessionManager->removeSession(session);
+}
+
+QString ClientInterface::buildChatContextLayer(
+    const QString &message, const QList<QString> &linkedFiles) const
+{
+    QString context;
+
+    auto *project = ProjectExplorer::ProjectManager::startupProject();
+    if (project) {
+        context += QString("# Active project: %1").arg(project->displayName());
+        context += QString(
+                       "\n# Project source root: %1"
+                       "\n#   All new source files, headers, QML and CMake edits MUST be "
+                       "created or modified under this directory. Use absolute paths "
+                       "rooted here, or project-relative paths.")
+                       .arg(project->projectDirectory().toUrlishString());
+
+        if (auto target = project->activeTarget()) {
+            if (auto buildConfig = target->activeBuildConfiguration()) {
+                context += QString(
+                               "\n# Build output directory (compiler artifacts only — do NOT "
+                               "create or edit source files here): %1")
+                               .arg(buildConfig->buildDirectory().toUrlishString());
+            }
+        }
+    } else {
+        context += QString("# No active project in IDE");
+    }
+
+    if (m_skillsManager && Settings::skillsSettings().enableSkills()) {
+        QStringList projectSkillDirs;
+        if (project) {
+            Settings::ProjectSettings projectSettings(project);
+            projectSkillDirs
+                = Settings::SkillsSettings::splitLines(projectSettings.projectSkillDirs());
+        }
+        m_skillsManager->configure(
+            project ? project->projectDirectory().toFSPathString() : QString(),
+            Settings::SkillsSettings::splitPaths(Settings::skillsSettings().globalSkillRoots()),
+            projectSkillDirs);
+
+        const QString alwaysOnSkills = m_skillsManager->alwaysOnBodies();
+        if (!alwaysOnSkills.isEmpty())
+            context += QString("\n\n") + alwaysOnSkills;
+
+        const QString skillsCatalog = m_skillsManager->catalogText();
+        if (!skillsCatalog.isEmpty())
+            context += QString("\n\n") + skillsCatalog;
+
+        static const QRegularExpression skillCommand(
+            QStringLiteral("(?:^|\\s)/([a-z0-9][a-z0-9-]*)"));
+        QStringList invokedSkillNames;
+        auto skillMatch = skillCommand.globalMatch(message);
+        while (skillMatch.hasNext()) {
+            const QString skillName = skillMatch.next().captured(1);
+            if (invokedSkillNames.contains(skillName))
+                continue;
+            const auto invokedSkill = m_skillsManager->findByName(skillName);
+            if (invokedSkill && !invokedSkill->body.isEmpty()) {
+                invokedSkillNames << skillName;
+                context += QString("\n\n# Invoked Skill: %1\n\n%2")
+                               .arg(invokedSkill->name, invokedSkill->body);
+            }
+        }
+    }
+
+    if (!linkedFiles.isEmpty()) {
+        context += "\n\nLinked files for reference:\n";
+        auto contentFiles = m_contextManager->getContentFiles(linkedFiles);
+        for (const auto &file : contentFiles)
+            context += QString("\nFile: %1\nContent:\n%2\n").arg(file.filename, file.content);
+    }
+
+    return context;
 }
 
 void ClientInterface::clearMessages()
 {
-    const auto providerName = Settings::generalSettings().caProvider();
-    auto *provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
-
-    if (provider && !m_chatFilePath.isEmpty()
-        && 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);
-        }
-    }
-
-    m_chatModel->clear();
+    if (m_history)
+        m_history->clear();
 }
 
 void ClientInterface::cancelRequest()
 {
-    QSet<PluginLLMCore::Provider *> providers;
-    for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
-        if (it.value().provider) {
-            providers.insert(it.value().provider);
-        }
-    }
-
-    for (auto *provider : providers) {
-        disconnect(provider->client(), nullptr, this, nullptr);
-    }
-
-    for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
-        const RequestContext &ctx = it.value();
-        if (ctx.provider) {
-            ctx.provider->cancelRequest(it.key());
-        }
-    }
-
+    const auto requests = m_activeRequests;
     m_activeRequests.clear();
-    m_accumulatedResponses.clear();
-    m_awaitingContinuation.clear();
 
-    LOG_MESSAGE("All requests cancelled and state cleared");
-}
-
-void ClientInterface::handleLLMResponse(const QString &response, const QJsonObject &request)
-{
-    const auto message = response.trimmed();
-
-    if (!message.isEmpty()) {
-        QString messageId = request["id"].toString();
-        m_chatModel->addMessage(message, ChatModel::ChatRole::Assistant, messageId);
+    for (auto it = requests.begin(); it != requests.end(); ++it) {
+        Session *session = it.value().session;
+        if (session && m_sessionManager)
+            m_sessionManager->removeSession(session);
     }
+
+    LOG_MESSAGE("All chat requests cancelled and state cleared");
 }
 
 QString ClientInterface::getCurrentFileContext() const
@@ -482,166 +468,11 @@ QString ClientInterface::getCurrentFileContext() const
     return QString("Current file context:\n%1\nFile content:\n%2").arg(fileInfo, content);
 }
 
-QString ClientInterface::getSystemPromptWithLinkedFiles(
-    const QString &basePrompt, const QList<QString> &linkedFiles) const
-{
-    QString updatedPrompt = basePrompt;
-
-    if (!linkedFiles.isEmpty()) {
-        updatedPrompt += "\n\nLinked files for reference:\n";
-
-        auto contentFiles = m_contextManager->getContentFiles(linkedFiles);
-        for (const auto &file : contentFiles) {
-            updatedPrompt += QString("\nFile: %1\nContent:\n%2\n").arg(file.filename, file.content);
-        }
-    }
-
-    return updatedPrompt;
-}
-
 Context::ContextManager *ClientInterface::contextManager() const
 {
     return m_contextManager;
 }
 
-void ClientInterface::handlePartialResponse(const QString &requestId, const QString &partialText)
-{
-    auto it = m_activeRequests.find(requestId);
-    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();
-    handleLLMResponse(m_accumulatedResponses[requestId], ctx.originalRequest);
-}
-
-void ClientInterface::handleFullResponse(const QString &requestId, const QString &fullText)
-{
-    auto it = m_activeRequests.find(requestId);
-    if (it == m_activeRequests.end())
-        return;
-
-    const RequestContext &ctx = it.value();
-
-    QString finalText = !fullText.isEmpty() ? fullText : m_accumulatedResponses[requestId];
-
-    QString applyError;
-    bool applySuccess
-        = Context::ChangesManager::instance().applyPendingEditsForRequest(requestId, &applyError);
-
-    if (!applySuccess) {
-        LOG_MESSAGE(QString("Some edits for request %1 were not auto-applied: %2")
-                        .arg(requestId, applyError));
-    }
-
-    LOG_MESSAGE(
-        "Message completed. Final response for message " + ctx.originalRequest["id"].toString()
-        + ": " + finalText);
-    emit messageReceivedCompletely();
-
-    m_activeRequests.erase(it);
-    m_accumulatedResponses.remove(requestId);
-    m_awaitingContinuation.remove(requestId);
-}
-
-void ClientInterface::handleRequestFinalized(
-    const ::LLMQore::RequestID &requestId, const ::LLMQore::CompletionInfo &info)
-{
-    if (!m_activeRequests.contains(requestId))
-        return;
-    if (!info.usage)
-        return;
-
-    const auto &u = *info.usage;
-    m_chatModel->setMessageUsage(
-        requestId, u.promptTokens, u.completionTokens, u.cachedPromptTokens, u.reasoningTokens);
-
-    emit messageUsageReceived(
-        u.promptTokens, u.completionTokens, u.cachedPromptTokens, u.reasoningTokens);
-
-    LOG_MESSAGE(QString("Chat usage [%1]: prompt=%2 completion=%3 cached=%4 reasoning=%5")
-                    .arg(requestId)
-                    .arg(u.promptTokens)
-                    .arg(u.completionTokens)
-                    .arg(u.cachedPromptTokens)
-                    .arg(u.reasoningTokens));
-}
-
-void ClientInterface::handleRequestFailed(const QString &requestId, const QString &error)
-{
-    auto it = m_activeRequests.find(requestId);
-    if (it == m_activeRequests.end())
-        return;
-
-    LOG_MESSAGE(QString("Chat request %1 failed: %2").arg(requestId, error));
-    emit errorOccurred(error);
-
-    m_activeRequests.erase(it);
-    m_accumulatedResponses.remove(requestId);
-    m_awaitingContinuation.remove(requestId);
-}
-
-void ClientInterface::handleThinkingBlockReceived(
-    const QString &requestId, const QString &thinking, const QString &signature)
-{
-    if (!m_activeRequests.contains(requestId)) {
-        LOG_MESSAGE(QString("Ignoring thinking block for non-chat request: %1").arg(requestId));
-        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::handleToolExecutionStarted(
-    const QString &requestId,
-    const QString &toolId,
-    const QString &toolName,
-    const QJsonObject &arguments)
-{
-    const auto requestIt = m_activeRequests.constFind(requestId);
-    if (requestIt == m_activeRequests.constEnd()) {
-        LOG_MESSAGE(QString("Ignoring tool execution start for non-chat request: %1").arg(requestId));
-        return;
-    }
-
-    if (requestIt->dropPreToolText) {
-        m_chatModel->dropTrailingAssistantMessage(requestId);
-    }
-    m_chatModel->addToolExecutionStatus(requestId, toolId, toolName, arguments);
-    m_awaitingContinuation.insert(requestId);
-}
-
-void ClientInterface::handleToolExecutionCompleted(
-    const QString &requestId,
-    const QString &toolId,
-    const QString &toolName,
-    const QString &toolOutput)
-{
-    if (!m_activeRequests.contains(requestId)) {
-        LOG_MESSAGE(QString("Ignoring tool execution result for non-chat request: %1").arg(requestId));
-        return;
-    }
-
-    m_chatModel->updateToolResult(requestId, toolId, toolName, toolOutput);
-}
-
 bool ClientInterface::isImageFile(const QString &filePath) const
 {
     static const QSet<QString> imageExtensions = {"png", "jpg", "jpeg", "gif", "webp", "bmp", "svg"};
@@ -689,46 +520,8 @@ QString ClientInterface::encodeImageToBase64(const QString &filePath) const
     return imageData.toBase64();
 }
 
-QVector<PluginLLMCore::ImageAttachment> ClientInterface::loadImagesFromStorage(
-    const QList<ChatModel::ImageAttachment> &storedImages) const
-{
-    QVector<PluginLLMCore::ImageAttachment> apiImages;
-
-    for (const auto &storedImage : storedImages) {
-        QString base64Data
-            = ChatSerializer::loadContentFromStorage(m_chatFilePath, storedImage.storedPath);
-        if (base64Data.isEmpty()) {
-            LOG_MESSAGE(QString("Warning: Failed to load image: %1").arg(storedImage.storedPath));
-            continue;
-        }
-
-        PluginLLMCore::ImageAttachment apiImage;
-        apiImage.data = base64Data;
-        apiImage.mediaType = storedImage.mediaType;
-        apiImage.isUrl = false;
-
-        apiImages.append(apiImage);
-    }
-
-    return apiImages;
-}
-
 void ClientInterface::setChatFilePath(const QString &filePath)
 {
-    if (!m_chatFilePath.isEmpty() && m_chatFilePath != filePath) {
-        const auto providerName = Settings::generalSettings().caProvider();
-        auto *provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
-
-        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);
-            }
-        }
-    }
-
     m_chatFilePath = filePath;
     m_chatModel->setChatFilePath(filePath);
 }

ChatView/ClientInterface.hpp

@@ -1,19 +1,25 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
 #include <QObject>
-#include <QSet>
+#include <QPointer>
 #include <QString>
-#include <QVector>
 
 #include "ChatModel.hpp"
-#include "Provider.hpp"
-#include "pluginllmcore/IPromptProvider.hpp"
+#include <ErrorInfo.hpp>
 #include <LLMQore/BaseClient.hpp>
+#include <ResponseEvent.hpp>
 #include <context/ContextManager.hpp>
 
+namespace QodeAssist {
+class SessionManager;
+class Session;
+class ConversationHistory;
+}
+
 namespace QodeAssist::Skills {
 class SkillsManager;
 }
@@ -25,23 +31,24 @@ class ClientInterface : public QObject
     Q_OBJECT
 
 public:
-    explicit ClientInterface(
-        ChatModel *chatModel, PluginLLMCore::IPromptProvider *promptProvider, QObject *parent = nullptr);
+    explicit ClientInterface(ChatModel *chatModel, QObject *parent = nullptr);
     ~ClientInterface();
 
     void setSkillsManager(Skills::SkillsManager *skillsManager);
+    void setSessionManager(SessionManager *sessionManager);
+    void setHistory(ConversationHistory *history);
+    void setActiveAgent(const QString &agentName);
+    void setActiveRole(const QString &roleId);
 
     void sendMessage(
         const QString &message,
         const QList<QString> &attachments = {},
-        const QList<QString> &linkedFiles = {},
-        bool useTools = false,
-        bool useThinking = false);
+        const QList<QString> &linkedFiles = {});
     void clearMessages();
     void cancelRequest();
 
     Context::ContextManager *contextManager() const;
-    
+
     void setChatFilePath(const QString &filePath);
     QString chatFilePath() const;
 
@@ -52,50 +59,35 @@ signals:
     void messageUsageReceived(
         int promptTokens, int completionTokens, int cachedPromptTokens, int reasoningTokens);
 
-private slots:
-    void handlePartialResponse(const QString &requestId, const QString &partialText);
-    void handleFullResponse(const QString &requestId, const QString &fullText);
-    void handleRequestFinalized(const ::LLMQore::RequestID &requestId, const ::LLMQore::CompletionInfo &info);
-    void handleRequestFailed(const QString &requestId, const QString &error);
-    void handleThinkingBlockReceived(
-        const QString &requestId, const QString &thinking, const QString &signature);
-    void handleToolExecutionStarted(
-        const QString &requestId,
-        const QString &toolId,
-        const QString &toolName,
-        const QJsonObject &arguments);
-    void handleToolExecutionCompleted(
-        const QString &requestId,
-        const QString &toolId,
-        const QString &toolName,
-        const QString &toolOutput);
-
 private:
-    void handleLLMResponse(const QString &response, const QJsonObject &request);
+    void onSessionEvent(Session *session, const QodeAssist::ResponseEvent &ev);
+    void onSessionFinished(const QString &requestId);
+    void onSessionFailed(const QString &requestId, const QodeAssist::ErrorInfo &error);
+
     QString getCurrentFileContext() const;
-    QString getSystemPromptWithLinkedFiles(
-        const QString &basePrompt, const QList<QString> &linkedFiles) const;
+    QString buildChatContextLayer(
+        const QString &message, const QList<QString> &linkedFiles) const;
+    QString requestIdForSession(Session *session) const;
     bool isImageFile(const QString &filePath) const;
     QString getMediaTypeForImage(const QString &filePath) const;
     QString encodeImageToBase64(const QString &filePath) const;
-    QVector<PluginLLMCore::ImageAttachment> loadImagesFromStorage(const QList<ChatModel::ImageAttachment> &storedImages) const;
 
     struct RequestContext
     {
         QJsonObject originalRequest;
-        PluginLLMCore::Provider *provider;
-        bool dropPreToolText = false;
+        QPointer<Session> session;
     };
 
-    PluginLLMCore::IPromptProvider *m_promptProvider = nullptr;
     ChatModel *m_chatModel;
     Context::ContextManager *m_contextManager;
+    QPointer<ConversationHistory> m_history;
     Skills::SkillsManager *m_skillsManager = nullptr;
+    QPointer<SessionManager> m_sessionManager;
+    QString m_activeAgent;
+    QString m_activeRoleId;
     QString m_chatFilePath;
 
     QHash<QString, RequestContext> m_activeRequests;
-    QHash<QString, QString> m_accumulatedResponses;
-    QSet<QString> m_awaitingContinuation;
 };
 
 } // namespace QodeAssist::Chat

ChatView/FileEditController.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "FileEditController.hpp"
 
@@ -9,15 +10,13 @@
 #include <coreplugin/editormanager/editormanager.h>
 #include <texteditor/texteditor.h>
 
-#include "ChatModel.hpp"
 #include "Logger.hpp"
 #include "context/ChangesManager.h"
 
 namespace QodeAssist::Chat {
 
-FileEditController::FileEditController(ChatModel *chatModel, QObject *parent)
+FileEditController::FileEditController(QObject *parent)
     : QObject(parent)
-    , m_chatModel(chatModel)
 {
     auto &changes = Context::ChangesManager::instance();
     connect(&changes, &Context::ChangesManager::fileEditAdded, this, [this](const QString &) {
@@ -79,7 +78,6 @@ void FileEditController::applyFileEdit(const QString &editId)
     LOG_MESSAGE(QString("Applying file edit: %1").arg(editId));
     if (Context::ChangesManager::instance().applyFileEdit(editId)) {
         emit infoMessage(QString("File edit applied successfully"));
-        updateFileEditStatus(editId, "applied");
     } else {
         auto edit = Context::ChangesManager::instance().getFileEdit(editId);
         emit errorOccurred(
@@ -94,7 +92,6 @@ void FileEditController::rejectFileEdit(const QString &editId)
     LOG_MESSAGE(QString("Rejecting file edit: %1").arg(editId));
     if (Context::ChangesManager::instance().rejectFileEdit(editId)) {
         emit infoMessage(QString("File edit rejected"));
-        updateFileEditStatus(editId, "rejected");
     } else {
         auto edit = Context::ChangesManager::instance().getFileEdit(editId);
         emit errorOccurred(
@@ -109,7 +106,6 @@ void FileEditController::undoFileEdit(const QString &editId)
     LOG_MESSAGE(QString("Undoing file edit: %1").arg(editId));
     if (Context::ChangesManager::instance().undoFileEdit(editId)) {
         emit infoMessage(QString("File edit undone successfully"));
-        updateFileEditStatus(editId, "rejected");
     } else {
         auto edit = Context::ChangesManager::instance().getFileEdit(editId);
         emit errorOccurred(
@@ -162,44 +158,6 @@ void FileEditController::openFileEditInEditor(const QString &editId)
     LOG_MESSAGE(QString("Opened file in editor: %1").arg(edit.filePath));
 }
 
-void FileEditController::updateFileEditStatus(const QString &editId, const QString &status)
-{
-    auto messages = m_chatModel->getChatHistory();
-    for (int i = 0; i < messages.size(); ++i) {
-        if (messages[i].role == Chat::ChatModel::FileEdit && messages[i].id == editId) {
-            QString content = messages[i].content;
-
-            const QString marker = "QODEASSIST_FILE_EDIT:";
-            int markerPos = content.indexOf(marker);
-
-            QString jsonStr = content;
-            if (markerPos >= 0) {
-                jsonStr = content.mid(markerPos + marker.length());
-            }
-
-            QJsonDocument doc = QJsonDocument::fromJson(jsonStr.toUtf8());
-            if (doc.isObject()) {
-                QJsonObject obj = doc.object();
-                obj["status"] = status;
-
-                auto edit = Context::ChangesManager::instance().getFileEdit(editId);
-                if (!edit.statusMessage.isEmpty()) {
-                    obj["status_message"] = edit.statusMessage;
-                }
-
-                QString updatedContent = marker
-                                         + QString::fromUtf8(
-                                             QJsonDocument(obj).toJson(QJsonDocument::Compact));
-                m_chatModel->updateMessageContent(editId, updatedContent);
-                LOG_MESSAGE(QString("Updated file edit status to: %1").arg(status));
-            }
-            break;
-        }
-    }
-
-    updateStats();
-}
-
 void FileEditController::applyAllForCurrentMessage()
 {
     if (m_currentRequestId.isEmpty()) {
@@ -222,13 +180,6 @@ void FileEditController::applyAllForCurrentMessage()
                 : QString("Failed to apply some file edits:\n%1").arg(errorMsg));
     }
 
-    auto edits = Context::ChangesManager::instance().getEditsForRequest(m_currentRequestId);
-    for (const auto &edit : edits) {
-        if (edit.status == Context::ChangesManager::Applied) {
-            updateFileEditStatus(edit.editId, "applied");
-        }
-    }
-
     updateStats();
 }
 
@@ -254,13 +205,6 @@ void FileEditController::undoAllForCurrentMessage()
                 : QString("Failed to undo some file edits:\n%1").arg(errorMsg));
     }
 
-    auto edits = Context::ChangesManager::instance().getEditsForRequest(m_currentRequestId);
-    for (const auto &edit : edits) {
-        if (edit.status == Context::ChangesManager::Rejected) {
-            updateFileEditStatus(edit.editId, "rejected");
-        }
-    }
-
     updateStats();
 }
 

ChatView/FileEditController.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
@@ -8,14 +9,12 @@
 
 namespace QodeAssist::Chat {
 
-class ChatModel;
-
 class FileEditController : public QObject
 {
     Q_OBJECT
 
 public:
-    explicit FileEditController(ChatModel *chatModel, QObject *parent = nullptr);
+    explicit FileEditController(QObject *parent = nullptr);
 
     void setCurrentRequestId(const QString &requestId);
     void clearCurrentRequestId();
@@ -40,9 +39,6 @@ signals:
     void errorOccurred(const QString &error);
 
 private:
-    void updateFileEditStatus(const QString &editId, const QString &status);
-
-    ChatModel *m_chatModel;
     QString m_currentRequestId;
     int m_totalEdits{0};
     int m_appliedEdits{0};

ChatView/FileItem.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "FileItem.hpp"
 

ChatView/FileItem.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

ChatView/FileMentionItem.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "FileMentionItem.hpp"
 

ChatView/FileMentionItem.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

ChatView/InputTokenCounter.cpp

@@ -1,30 +1,27 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "InputTokenCounter.hpp"
 
 #include <algorithm>
 
-#include <LLMQore/ToolsManager.hpp>
-#include <QJsonArray>
-#include <QJsonDocument>
-
 #include <utils/aspects.h>
 
 #include "ChatAssistantSettings.hpp"
-#include "ChatModel.hpp"
-#include "GeneralSettings.hpp"
 #include "Logger.hpp"
-#include "ProvidersManager.hpp"
 #include "context/ContextManager.hpp"
 #include "context/TokenUtils.hpp"
 
+#include <ConversationHistory.hpp>
+#include <Message.hpp>
+
 namespace QodeAssist::Chat {
 
 InputTokenCounter::InputTokenCounter(
-    ChatModel *chatModel, Context::ContextManager *contextManager, QObject *parent)
+    ConversationHistory *history, Context::ContextManager *contextManager, QObject *parent)
     : QObject(parent)
-    , m_chatModel(chatModel)
+    , m_history(history)
     , m_contextManager(contextManager)
 {
     auto &settings = Settings::chatAssistantSettings();
@@ -41,12 +38,6 @@ InputTokenCounter::InputTokenCounter(
         this,
         &InputTokenCounter::recompute);
 
-    connect(&Settings::generalSettings().caProvider, &Utils::BaseAspect::changed, this, [this]() {
-        rewireToolsChangedConnection();
-        recompute();
-    });
-
-    rewireToolsChangedConnection();
     recompute();
 }
 
@@ -73,24 +64,6 @@ void InputTokenCounter::setLinkedFiles(const QStringList &linkedFiles)
     recompute();
 }
 
-void InputTokenCounter::rewireToolsChangedConnection()
-{
-    if (m_toolsChangedConn)
-        QObject::disconnect(m_toolsChangedConn);
-    m_toolsChangedConn = {};
-
-    const auto providerName = Settings::generalSettings().caProvider();
-    auto *provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(providerName);
-    if (!provider)
-        return;
-    auto *tm = provider->toolsManager();
-    if (!tm)
-        return;
-
-    m_toolsChangedConn = connect(
-        tm, &::LLMQore::ToolRegistry::toolsChanged, this, &InputTokenCounter::recompute);
-}
-
 void InputTokenCounter::recompute()
 {
     int inputTokens = m_messageTokens;
@@ -129,24 +102,10 @@ void InputTokenCounter::recompute()
         }
     }
 
-    const auto &history = m_chatModel->getChatHistory();
-    for (const auto &message : history) {
-        inputTokens += Context::TokenUtils::estimateTokens(message.content);
-        inputTokens += 4; // + role
-    }
-
-    if (settings.enableChatTools()) {
-        const auto providerName = Settings::generalSettings().caProvider();
-        if (auto *provider = PluginLLMCore::ProvidersManager::instance().getProviderByName(
-                providerName)) {
-            if (auto *tm = provider->toolsManager()) {
-                const QJsonArray toolDefs = tm->getToolsDefinitions();
-                if (!toolDefs.isEmpty()) {
-                    const QByteArray serialized
-                        = QJsonDocument(toolDefs).toJson(QJsonDocument::Compact);
-                    inputTokens += static_cast<int>(serialized.size() / 4);
-                }
-            }
+    if (m_history) {
+        for (const auto &message : m_history->messages()) {
+            inputTokens += Context::TokenUtils::estimateTokens(message.text());
+            inputTokens += 4; // + role
         }
     }
 

ChatView/InputTokenCounter.hpp

@@ -1,26 +1,31 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
 #include <QObject>
 #include <QStringList>
 
+namespace QodeAssist {
+class ConversationHistory;
+}
+
 namespace QodeAssist::Context {
 class ContextManager;
 }
 
 namespace QodeAssist::Chat {
 
-class ChatModel;
-
 class InputTokenCounter : public QObject
 {
     Q_OBJECT
 
 public:
     InputTokenCounter(
-        ChatModel *chatModel, Context::ContextManager *contextManager, QObject *parent = nullptr);
+        ConversationHistory *history,
+        Context::ContextManager *contextManager,
+        QObject *parent = nullptr);
 
     int inputTokens() const;
 
@@ -36,11 +41,8 @@ signals:
     void inputTokensChanged();
 
 private:
-    void rewireToolsChangedConnection();
-
-    ChatModel *m_chatModel;
+    ConversationHistory *m_history;
     Context::ContextManager *m_contextManager;
-    QMetaObject::Connection m_toolsChangedConn;
 
     QStringList m_attachments;
     QStringList m_linkedFiles;

ChatView/MessagePart.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

ChatView/SessionFileRegistry.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "SessionFileRegistry.hpp"
 

ChatView/SessionFileRegistry.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

ChatView/icons/warning-icon.svg

@@ -0,0 +1,5 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M12 3L22 20H2L12 3Z" stroke="black" stroke-width="2" stroke-linejoin="round"/>
+<path d="M12 10V14" stroke="black" stroke-width="2" stroke-linecap="round"/>
+<path d="M12 17H12.01" stroke="black" stroke-width="2.4" stroke-linecap="round"/>
+</svg>

ChatView/qml/RootItem.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls
@@ -19,6 +20,9 @@ ChatRootView {
         colorGroup: SystemPalette.Active
     }
 
+    property bool hasActiveError: false
+    readonly property color errorColor: "#d32f2f"
+
     palette {
         window: sysPalette.window
         windowText: sysPalette.windowText
@@ -134,43 +138,31 @@ ChatRootView {
             relocateTooltip.text: (typeof _chatview !== 'undefined')
                                    ? qsTr("Move this chat to an editor tab")
                                    : qsTr("Move this chat to a separate window")
-            toolsButton {
-                checked: root.useTools
-                onCheckedChanged: {
-                    root.useTools = toolsButton.checked
-                }
-            }
-            thinkingMode {
-                checked: root.useThinking
-                enabled: root.isThinkingSupport
-                onCheckedChanged: {
-                    root.useThinking = thinkingMode.checked
-                }
-            }
             settingsButton.onClicked: root.openSettings()
-            configSelector {
-                model: root.availableConfigurations
-                displayText: root.currentConfiguration
+            agentSelector {
+                model: root.availableChatAgents
+                displayText: root.currentChatAgent
                 onActivated: function(index) {
-                    if (index > 0) {
-                        root.applyConfiguration(root.availableConfigurations[index])
-                    }
+                    root.currentChatAgent = root.availableChatAgents[index]
                 }
 
+                Component.onCompleted: root.loadAvailableChatAgents()
+
                 popup.onAboutToShow: {
-                    root.loadAvailableConfigurations()
+                    root.loadAvailableChatAgents()
                 }
             }
-
             roleSelector {
-                model: root.availableAgentRoles
-                displayText: root.currentAgentRole
+                model: root.availableRoles
+                displayText: root.currentRole
                 onActivated: function(index) {
-                    root.applyAgentRole(root.availableAgentRoles[index])
+                    root.currentRole = root.availableRoles[index]
                 }
 
+                Component.onCompleted: root.loadAvailableRoles()
+
                 popup.onAboutToShow: {
-                    root.loadAvailableAgentRoles()
+                    root.loadAvailableRoles()
                 }
             }
         }
@@ -411,11 +403,10 @@ ChatRootView {
             QQC.TextArea {
                 id: messageInput
 
-                placeholderText: Qt.platform.os === "osx"
-                                 ? qsTr("Type your message here... (⌘+↩ to send)")
-                                 : qsTr("Type your message here... (Ctrl+Enter to send)")
+                placeholderText: qsTr("Type your message here... (%1 to send)").arg(root.sendShortcutText)
                 placeholderTextColor: palette.mid
                 color: palette.text
+                wrapMode: TextArea.Wrap
                 background: Rectangle {
                     radius: 2
                     color: palette.base
@@ -494,6 +485,9 @@ ChatRootView {
                             skillCommandPopup.dismiss()
                             event.accepted = true
                         }
+                    } else if (root.isSendShortcut(event.key, event.modifiers)) {
+                        root.sendChatMessage()
+                        event.accepted = true
                     }
                 }
 
@@ -586,13 +580,21 @@ ChatRootView {
             Layout.preferredHeight: 40
 
             isCompressing: root.isCompressing
+            isProcessing: root.isRequestInProgress
             sendButton.onClicked: !root.isRequestInProgress ? root.sendChatMessage()
                                                             : root.cancelRequest()
-            sendButton.icon.source: !root.isRequestInProgress ? "qrc:/qt/qml/ChatView/icons/chat-icon.svg"
-                                                              : "qrc:/qt/qml/ChatView/icons/chat-pause-icon.svg"
-            sendButton.text: !root.isRequestInProgress ? qsTr("Send") : qsTr("Stop")
-            sendButtonTooltip.text: !root.isRequestInProgress ? qsTr("Send message to LLM %1").arg(Qt.platform.os === "osx" ? "Cmd+Return" : "Ctrl+Return")
-                                                         : qsTr("Stop")
+            sendButton.icon.source: root.isRequestInProgress
+                                    ? ""
+                                    : (root.hasActiveError ? "qrc:/qt/qml/ChatView/icons/warning-icon.svg"
+                                                           : "qrc:/qt/qml/ChatView/icons/chat-icon.svg")
+            sendButton.text: root.isRequestInProgress ? qsTr("Stop") : qsTr("Send")
+            sendButton.accentColor: (root.hasActiveError && !root.isRequestInProgress)
+                                    ? root.errorColor : "transparent"
+            sendButtonTooltip.text: root.isRequestInProgress
+                                    ? qsTr("Stop")
+                                    : (root.hasActiveError
+                                       ? root.lastErrorMessage
+                                       : qsTr("Send message to LLM %1").arg(root.sendShortcutText))
             compressButton.onClicked: compressConfirmDialog.open()
             cancelCompressButton.onClicked: root.cancelCompression()
             syncOpenFiles {
@@ -667,6 +669,7 @@ ChatRootView {
     }
 
     function sendChatMessage() {
+        root.hasActiveError = false
         root.sendMessage(fileMentionPopup.expandMentions(messageInput.text))
         messageInput.text = ""
         fileMentionPopup.clearMentions()
@@ -689,13 +692,122 @@ ChatRootView {
         onAccepted: root.compressCurrentChat()
     }
 
-    Toast {
-        id: errorToast
-        z: 1000
+    Rectangle {
+        id: errorBanner
 
-        color: Qt.rgba(0.8, 0.2, 0.2, 0.9)
-        border.color: Qt.darker(infoToast.color, 1.3)
-        toastTextColor: "#FFFFFF"
+        z: 1000
+        visible: root.hasActiveError && root.lastErrorMessage.length > 0
+
+        width: parent.width / 2
+        anchors.right: parent.right
+        anchors.bottom: parent.bottom
+        anchors.rightMargin: 10
+        anchors.bottomMargin: bottomBar.height + 48
+
+        height: visible ? errorRow.implicitHeight + 12 : 0
+
+        color: Qt.rgba(0.83, 0.18, 0.18, 0.96)
+        radius: 6
+        border.color: Qt.darker(color, 1.3)
+        border.width: 1
+
+        RowLayout {
+            id: errorRow
+
+            anchors.left: parent.left
+            anchors.right: parent.right
+            anchors.verticalCenter: parent.verticalCenter
+            anchors.leftMargin: 10
+            anchors.rightMargin: 6
+            spacing: 8
+
+            TextEdit {
+                Layout.fillWidth: true
+                text: root.lastErrorMessage
+                color: "#FFFFFF"
+                font.pixelSize: 12
+                wrapMode: TextEdit.Wrap
+                readOnly: true
+                selectByMouse: true
+                selectionColor: Qt.darker(errorBanner.color, 1.3)
+            }
+
+            Rectangle {
+                id: copyErrorButton
+
+                property bool copied: false
+
+                Layout.alignment: Qt.AlignTop
+                implicitWidth: copyErrorLabel.implicitWidth + 18
+                implicitHeight: 22
+                radius: 4
+                color: copyErrorMouse.containsMouse ? Qt.rgba(1, 1, 1, 0.28)
+                                                    : Qt.rgba(1, 1, 1, 0.16)
+                border.color: Qt.rgba(1, 1, 1, 0.45)
+                border.width: 1
+
+                Behavior on color { ColorAnimation { duration: 120 } }
+
+                Text {
+                    id: copyErrorLabel
+
+                    anchors.centerIn: parent
+                    text: copyErrorButton.copied ? qsTr("Copied") : qsTr("Copy")
+                    color: "#FFFFFF"
+                    font.pixelSize: 12
+                }
+
+                MouseArea {
+                    id: copyErrorMouse
+
+                    anchors.fill: parent
+                    hoverEnabled: true
+                    cursorShape: Qt.PointingHandCursor
+                    onClicked: {
+                        root.copyToClipboard(root.lastErrorMessage)
+                        copyErrorButton.copied = true
+                        copyErrorResetTimer.restart()
+                    }
+                }
+
+                Timer {
+                    id: copyErrorResetTimer
+
+                    interval: 1500
+                    onTriggered: copyErrorButton.copied = false
+                }
+            }
+
+            Rectangle {
+                id: closeErrorButton
+
+                Layout.alignment: Qt.AlignTop
+                implicitWidth: 22
+                implicitHeight: 22
+                radius: 4
+                color: closeErrorMouse.containsMouse ? Qt.rgba(1, 1, 1, 0.28) : "transparent"
+                border.color: Qt.rgba(1, 1, 1, 0.45)
+                border.width: closeErrorMouse.containsMouse ? 1 : 0
+
+                Behavior on color { ColorAnimation { duration: 120 } }
+
+                Text {
+                    anchors.centerIn: parent
+                    text: "✕"
+                    color: "#FFFFFF"
+                    font.pixelSize: 12
+                }
+
+                MouseArea {
+                    id: closeErrorMouse
+
+                    anchors.fill: parent
+                    hoverEnabled: true
+                    cursorShape: Qt.PointingHandCursor
+                    onClicked: root.hasActiveError = false
+                }
+            }
+        }
     }
 
     Toast {
@@ -715,27 +827,14 @@ ChatRootView {
         x: (parent.width - width) / 2
         y: (parent.height - height) / 2
 
-        baseSystemPrompt: root.baseSystemPrompt
-        currentAgentRole: root.currentAgentRole
-        currentAgentRoleDescription: root.currentAgentRoleDescription
-        currentAgentRoleSystemPrompt: root.currentAgentRoleSystemPrompt
-        activeRules: root.activeRules
-        activeRulesCount: root.activeRulesCount
-
         onOpenSettings: root.openSettings()
-        onOpenAgentRolesSettings: root.openAgentRolesSettings()
-        onOpenRulesFolder: root.openRulesFolder()
-        onRefreshRules: root.refreshRules()
-        onRuleSelected: function(index) {
-            contextViewer.selectedRuleContent = root.getRuleContent(index)
-        }
     }
 
     Connections {
         target: root
         function onLastErrorMessageChanged() {
             if (root.lastErrorMessage.length > 0) {
-                errorToast.show(root.lastErrorMessage)
+                root.hasActiveError = true
             }
         }
         function onLastInfoMessageChanged() {

ChatView/qml/chatparts/ChatItem.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import ChatView
@@ -355,10 +356,9 @@ Rectangle {
                 smooth: true
                 mipmap: true
 
-                BusyIndicator {
+                QoABusyIndicator {
                     anchors.centerIn: parent
                     running: imageDisplay.status === Image.Loading
-                    visible: running
                 }
 
                 Text {

ChatView/qml/chatparts/CodeBlock.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls

ChatView/qml/chatparts/FileEditBlock.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls

ChatView/qml/chatparts/TextBlock.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import Qt.labs.platform as Platform

ChatView/qml/chatparts/ThinkingBlock.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import Qt.labs.platform as Platform

ChatView/qml/chatparts/ToolBlock.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import Qt.labs.platform as Platform

ChatView/qml/controls/AttachedFilesPlace.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls

ChatView/qml/controls/BottomBar.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls
@@ -19,6 +20,7 @@ Rectangle {
     property alias cancelCompressButton: cancelCompressButtonId
 
     property bool isCompressing: false
+    property bool isProcessing: false
     property alias sendButtonTooltip: sendButtonTooltipId
 
     color: palette.window.hslLightness > 0.5 ?
@@ -107,7 +109,7 @@ Rectangle {
             visible: root.isCompressing
             spacing: 6
 
-            BusyIndicator {
+            QoABusyIndicator {
                 id: compressBusyIndicator
 
                 anchors.verticalCenter: parent.verticalCenter
@@ -159,11 +161,24 @@ Rectangle {
         QoAButton {
             id: sendButtonId
 
+            leftPadding: root.isProcessing ? 22 : 4
+
             icon {
                 height: 15
                 width: 15
             }
 
+            QoABusyIndicator {
+                id: sendBusyIndicator
+
+                anchors.left: parent.left
+                anchors.leftMargin: 5
+                anchors.verticalCenter: parent.verticalCenter
+                width: 14
+                height: 14
+                running: root.isProcessing
+            }
+
             QoAToolTip {
                 id: sendButtonTooltipId
 

ChatView/qml/controls/ContextViewer.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls

ChatView/qml/controls/FileEditsActionBar.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls

ChatView/qml/controls/FileMentionPopup.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls

ChatView/qml/controls/MessageNavigator.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls

ChatView/qml/controls/SkillCommandPopup.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls

ChatView/qml/controls/SplitDropZone.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Controls

ChatView/qml/controls/Toast.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 

ChatView/qml/controls/TopBar.qml

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 import QtQuick
 import QtQuick.Layouts
@@ -22,11 +23,9 @@ Rectangle {
     property alias pinButton: pinButtonId
     property alias relocateButton: relocateButtonId
     property alias contextButton: contextButtonId
-    property alias toolsButton: toolsButtonId
-    property alias thinkingMode: thinkingModeId
     property alias settingsButton: settingsButtonId
-    property alias configSelector: configSelectorId
-    property alias roleSelector: roleSelector
+    property alias agentSelector: agentSelectorId
+    property alias roleSelector: roleSelectorId
     property alias relocateTooltip: relocateTooltipId
 
     color: palette.window.hslLightness > 0.5 ?
@@ -133,7 +132,7 @@ Rectangle {
             }
 
             QoAComboBox {
-                id: configSelectorId
+                id: agentSelectorId
 
                 implicitHeight: 25
 
@@ -141,14 +140,14 @@ Rectangle {
                 currentIndex: 0
 
                 QoAToolTip {
-                    visible: configSelectorId.hovered
+                    visible: agentSelectorId.hovered
                     delay: 250
-                    text: qsTr("Switch saved AI configuration")
+                    text: qsTr("Select chat agent (provider and model come from the agent)")
                 }
             }
 
             QoAComboBox {
-                id: roleSelector
+                id: roleSelectorId
 
                 implicitHeight: 25
 
@@ -156,9 +155,9 @@ Rectangle {
                 currentIndex: 0
 
                 QoAToolTip {
-                    visible: roleSelector.hovered
+                    visible: roleSelectorId.hovered
                     delay: 250
-                    text: qsTr("Switch agent role (different system prompts)")
+                    text: qsTr("Select the role (system prompt) for the chat")
                 }
             }
         }
@@ -166,62 +165,6 @@ Rectangle {
         Row {
             spacing: 10
 
-            QoAButton {
-                id: toolsButtonId
-
-                anchors.verticalCenter: parent.verticalCenter
-
-                checkable: true
-                opacity: enabled ? 1.0 : 0.2
-
-                icon {
-                    source: checked ? "qrc:/qt/qml/ChatView/icons/tools-icon-on.svg"
-                                    : "qrc:/qt/qml/ChatView/icons/tools-icon-off.svg"
-                    color: palette.window.hslLightness > 0.5 ? "#000000" : "#FFFFFF"
-                    height: 15
-                    width: 15
-                }
-
-                QoAToolTip {
-                    visible: toolsButtonId.hovered
-                    delay: 250
-                    text: {
-                        if (!toolsButtonId.enabled) {
-                            return qsTr("Tools are disabled in General Settings")
-                        }
-                        return toolsButtonId.checked
-                                ? qsTr("Tools enabled: AI can use tools to read files, search project, and build code")
-                                : qsTr("Tools disabled: Simple conversation without tool access")
-                    }
-                }
-            }
-
-            QoAButton {
-                id: thinkingModeId
-
-                anchors.verticalCenter: parent.verticalCenter
-
-                checkable: true
-                opacity: enabled ? 1.0 : 0.2
-
-                icon {
-                    source: checked ? "qrc:/qt/qml/ChatView/icons/thinking-icon-on.svg"
-                                    : "qrc:/qt/qml/ChatView/icons/thinking-icon-off.svg"
-                    color: palette.window.hslLightness > 0.5 ? "#000000" : "#FFFFFF"
-                    height: 15
-                    width: 15
-                }
-
-                QoAToolTip {
-                    visible: thinkingModeId.hovered
-                    delay: 250
-                    text: thinkingModeId.enabled
-                        ? (thinkingModeId.checked ? qsTr("Thinking Mode enabled (Check model list support it)")
-                                                  : qsTr("Thinking Mode disabled"))
-                        : qsTr("Thinking Mode is not available for this provider")
-                }
-            }
-
             QoAButton {
                 id: settingsButtonId
 

CodeHandler.cpp

@@ -1,6 +1,7 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // Copyright (C) 2025 Povilas Kanapickas <povilas@radix.lt>
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "CodeHandler.hpp"
 #include <settings/CodeCompletionSettings.hpp>

CodeHandler.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

ConfigurationManager.cpp

@@ -1,235 +0,0 @@
-// Copyright (C) 2025-2026 Petr Mironychev
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "ConfigurationManager.hpp"
-
-#include <settings/ButtonAspect.hpp>
-#include <QTimer>
-
-#include "QodeAssisttr.h"
-
-namespace QodeAssist {
-
-ConfigurationManager &ConfigurationManager::instance()
-{
-    static ConfigurationManager instance;
-    return instance;
-}
-
-void ConfigurationManager::init()
-{
-    setupConnections();
-    updateAllTemplateDescriptions();
-    checkAllTemplate();
-}
-
-void ConfigurationManager::updateTemplateDescription(const Utils::StringAspect &templateAspect)
-{
-    PluginLLMCore::PromptTemplate *templ = m_templateManger.getFimTemplateByName(templateAspect.value());
-
-    if (!templ) {
-        return;
-    }
-
-    if (&templateAspect == &m_generalSettings.ccTemplate) {
-        m_generalSettings.ccTemplateDescription.setValue(templ->description());
-    } else if (&templateAspect == &m_generalSettings.caTemplate) {
-        m_generalSettings.caTemplateDescription.setValue(templ->description());
-    } else if (&templateAspect == &m_generalSettings.qrTemplate) {
-        m_generalSettings.qrTemplateDescription.setValue(templ->description());
-    }
-}
-
-void ConfigurationManager::updateAllTemplateDescriptions()
-{
-    updateTemplateDescription(m_generalSettings.ccTemplate);
-    updateTemplateDescription(m_generalSettings.caTemplate);
-    updateTemplateDescription(m_generalSettings.qrTemplate);
-}
-
-void ConfigurationManager::checkTemplate(const Utils::StringAspect &templateAspect)
-{
-    PluginLLMCore::PromptTemplate *templ = m_templateManger.getFimTemplateByName(templateAspect.value());
-
-    if (templ->name() == templateAspect.value())
-        return;
-
-    if (&templateAspect == &m_generalSettings.ccTemplate) {
-        m_generalSettings.ccTemplate.setValue(templ->name());
-    } else if (&templateAspect == &m_generalSettings.caTemplate) {
-        m_generalSettings.caTemplate.setValue(templ->name());
-    }
-}
-
-void ConfigurationManager::checkAllTemplate()
-{
-    checkTemplate(m_generalSettings.ccTemplate);
-    checkTemplate(m_generalSettings.caTemplate);
-}
-
-ConfigurationManager::ConfigurationManager(QObject *parent)
-    : QObject(parent)
-    , m_generalSettings(Settings::generalSettings())
-    , m_providersManager(PluginLLMCore::ProvidersManager::instance())
-    , m_templateManger(PluginLLMCore::PromptTemplateManager::instance())
-{}
-
-void ConfigurationManager::setupConnections()
-{
-    using Config = ConfigurationManager;
-    using Button = ButtonAspect;
-
-    connect(&m_generalSettings.ccSelectProvider, &Button::clicked, this, &Config::selectProvider);
-    connect(&m_generalSettings.caSelectProvider, &Button::clicked, this, &Config::selectProvider);
-    connect(&m_generalSettings.qrSelectProvider, &Button::clicked, this, &Config::selectProvider);
-    connect(&m_generalSettings.ccSelectModel, &Button::clicked, this, &Config::selectModel);
-    connect(&m_generalSettings.caSelectModel, &Button::clicked, this, &Config::selectModel);
-    connect(&m_generalSettings.qrSelectModel, &Button::clicked, this, &Config::selectModel);
-    connect(&m_generalSettings.ccSelectTemplate, &Button::clicked, this, &Config::selectTemplate);
-    connect(&m_generalSettings.caSelectTemplate, &Button::clicked, this, &Config::selectTemplate);
-    connect(&m_generalSettings.qrSelectTemplate, &Button::clicked, this, &Config::selectTemplate);
-    connect(&m_generalSettings.ccSetUrl, &Button::clicked, this, &Config::selectUrl);
-    connect(&m_generalSettings.caSetUrl, &Button::clicked, this, &Config::selectUrl);
-    connect(&m_generalSettings.qrSetUrl, &Button::clicked, this, &Config::selectUrl);
-
-    connect(
-        &m_generalSettings.ccPreset1SelectProvider, &Button::clicked, this, &Config::selectProvider);
-    connect(&m_generalSettings.ccPreset1SetUrl, &Button::clicked, this, &Config::selectUrl);
-    connect(&m_generalSettings.ccPreset1SelectModel, &Button::clicked, this, &Config::selectModel);
-    connect(
-        &m_generalSettings.ccPreset1SelectTemplate, &Button::clicked, this, &Config::selectTemplate);
-
-    connect(&m_generalSettings.ccTemplate, &Utils::StringAspect::changed, this, [this]() {
-        updateTemplateDescription(m_generalSettings.ccTemplate);
-    });
-
-    connect(&m_generalSettings.caTemplate, &Utils::StringAspect::changed, this, [this]() {
-        updateTemplateDescription(m_generalSettings.caTemplate);
-    });
-
-    connect(&m_generalSettings.qrTemplate, &Utils::StringAspect::changed, this, [this]() {
-        updateTemplateDescription(m_generalSettings.qrTemplate);
-    });
-}
-
-void ConfigurationManager::selectProvider()
-{
-    const auto providersList = m_providersManager.providersNames();
-
-    auto *settingsButton = qobject_cast<ButtonAspect *>(sender());
-    if (!settingsButton)
-        return;
-
-    auto &targetSettings = (settingsButton == &m_generalSettings.ccSelectProvider)
-                               ? m_generalSettings.ccProvider
-                           : settingsButton == &m_generalSettings.ccPreset1SelectProvider
-                               ? m_generalSettings.ccPreset1Provider
-                           : settingsButton == &m_generalSettings.qrSelectProvider
-                               ? m_generalSettings.qrProvider
-                               : m_generalSettings.caProvider;
-
-    QTimer::singleShot(0, this, [this, providersList, &targetSettings] {
-        m_generalSettings.showSelectionDialog(
-            providersList, targetSettings, Tr::tr("Select LLM Provider"), Tr::tr("Providers:"));
-    });
-}
-
-void ConfigurationManager::selectModel()
-{
-    auto *settingsButton = qobject_cast<ButtonAspect *>(sender());
-    if (!settingsButton)
-        return;
-
-    const bool isCodeCompletion = (settingsButton == &m_generalSettings.ccSelectModel);
-    const bool isPreset1 = (settingsButton == &m_generalSettings.ccPreset1SelectModel);
-    const bool isQuickRefactor = (settingsButton == &m_generalSettings.qrSelectModel);
-
-    const QString providerName = isCodeCompletion ? m_generalSettings.ccProvider.volatileValue()
-                                 : isPreset1 ? m_generalSettings.ccPreset1Provider.volatileValue()
-                                 : isQuickRefactor ? m_generalSettings.qrProvider.volatileValue()
-                                             : m_generalSettings.caProvider.volatileValue();
-
-    const auto providerUrl = isCodeCompletion ? m_generalSettings.ccUrl.volatileValue()
-                             : isPreset1      ? m_generalSettings.ccPreset1Url.volatileValue()
-                             : isQuickRefactor ? m_generalSettings.qrUrl.volatileValue()
-                                              : m_generalSettings.caUrl.volatileValue();
-
-    auto *targetSettings = &(isCodeCompletion ? m_generalSettings.ccModel
-                              : isPreset1      ? m_generalSettings.ccPreset1Model
-                              : isQuickRefactor ? m_generalSettings.qrModel
-                                               : m_generalSettings.caModel);
-
-    if (auto provider = m_providersManager.getProviderByName(providerName)) {
-        if (!provider->capabilities().testFlag(PluginLLMCore::ProviderCapability::ModelListing)) {
-            m_generalSettings.showModelsNotSupportedDialog(*targetSettings);
-            return;
-        }
-
-        provider->getInstalledModels(providerUrl)
-            .then(this, [this, targetSettings](const QList<QString> &modelList) {
-                if (modelList.isEmpty()) {
-                    m_generalSettings.showModelsNotFoundDialog(*targetSettings);
-                    return;
-                }
-                m_generalSettings.showSelectionDialog(
-                    modelList, *targetSettings, Tr::tr("Select LLM Model"), Tr::tr("Models:"));
-            });
-    }
-}
-
-void ConfigurationManager::selectTemplate()
-{
-    auto *settingsButton = qobject_cast<ButtonAspect *>(sender());
-    if (!settingsButton)
-        return;
-
-    const bool isCodeCompletion = (settingsButton == &m_generalSettings.ccSelectTemplate);
-    const bool isPreset1 = (settingsButton == &m_generalSettings.ccPreset1SelectTemplate);
-    const bool isQuickRefactor = (settingsButton == &m_generalSettings.qrSelectTemplate);
-    const QString providerName = isCodeCompletion ? m_generalSettings.ccProvider.volatileValue()
-                                 : isPreset1 ? m_generalSettings.ccPreset1Provider.volatileValue()
-                                 : isQuickRefactor ? m_generalSettings.qrProvider.volatileValue()
-                                             : m_generalSettings.caProvider.volatileValue();
-    auto providerID = m_providersManager.getProviderByName(providerName)->providerID();
-
-    const auto templateList = isCodeCompletion || isPreset1
-                                  ? m_templateManger.getFimTemplatesForProvider(providerID)
-                                  : m_templateManger.getChatTemplatesForProvider(providerID);
-
-    auto &targetSettings = isCodeCompletion ? m_generalSettings.ccTemplate
-                           : isPreset1      ? m_generalSettings.ccPreset1Template
-                           : isQuickRefactor ? m_generalSettings.qrTemplate
-                                            : m_generalSettings.caTemplate;
-
-    QTimer::singleShot(0, &m_generalSettings, [this, templateList, &targetSettings]() {
-        m_generalSettings.showSelectionDialog(
-            templateList, targetSettings, Tr::tr("Select Template"), Tr::tr("Templates:"));
-    });
-}
-
-void ConfigurationManager::selectUrl()
-{
-    auto *settingsButton = qobject_cast<ButtonAspect *>(sender());
-    if (!settingsButton)
-        return;
-
-    QStringList urls;
-    for (const auto &name : m_providersManager.providersNames()) {
-        const auto url = m_providersManager.getProviderByName(name)->url();
-        if (!urls.contains(url))
-            urls.append(url);
-    }
-
-    auto &targetSettings = (settingsButton == &m_generalSettings.ccSetUrl) ? m_generalSettings.ccUrl
-                           : settingsButton == &m_generalSettings.ccPreset1SetUrl
-                               ? m_generalSettings.ccPreset1Url
-                           : settingsButton == &m_generalSettings.qrSetUrl
-                               ? m_generalSettings.qrUrl
-                               : m_generalSettings.caUrl;
-
-    QTimer::singleShot(0, &m_generalSettings, [this, urls, &targetSettings]() {
-        m_generalSettings.showUrlSelectionDialog(targetSettings, urls);
-    });
-}
-
-} // namespace QodeAssist

ConfigurationManager.hpp

@@ -1,47 +0,0 @@
-// Copyright (C) 2025-2026 Petr Mironychev
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <QObject>
-
-#include "pluginllmcore/PromptTemplateManager.hpp"
-#include "pluginllmcore/ProvidersManager.hpp"
-#include "settings/GeneralSettings.hpp"
-
-namespace QodeAssist {
-
-class ConfigurationManager : public QObject
-{
-    Q_OBJECT
-
-public:
-    static ConfigurationManager &instance();
-
-    void init();
-
-    void updateTemplateDescription(const Utils::StringAspect &templateAspect);
-    void updateAllTemplateDescriptions();
-    void checkTemplate(const Utils::StringAspect &templateAspect);
-    void checkAllTemplate();
-
-public slots:
-    void selectProvider();
-    void selectModel();
-    void selectTemplate();
-    void selectUrl();
-
-private:
-    explicit ConfigurationManager(QObject *parent = nullptr);
-    ~ConfigurationManager() = default;
-    ConfigurationManager(const ConfigurationManager &) = delete;
-    ConfigurationManager &operator=(const ConfigurationManager &) = delete;
-
-    Settings::GeneralSettings &m_generalSettings;
-    PluginLLMCore::ProvidersManager &m_providersManager;
-    PluginLLMCore::PromptTemplateManager &m_templateManger;
-
-    void setupConnections();
-};
-
-} // namespace QodeAssist

LICENSE

@@ -1,3 +1,24 @@
+===============================================================
+ADDITIONAL TERMS UNDER GPLv3 SECTION 7(b)
+===============================================================
+
+In accordance with Section 7(b) of the GNU General Public License v3.0,
+the following additional attribution term applies to QodeAssist:
+
+  You must preserve all author attributions, copyright notices, and the
+  project name "QodeAssist" in all copies and modified versions,
+  including in source file headers, the plugin metadata
+  (QodeAssist.json.in), and the About dialog or equivalent user-facing
+  identification. Modified versions must be clearly marked as different
+  from the original.
+
+This is a reasonable attribution requirement permitted under GPLv3
+§7(b) and §7(c). It supplements the notice-preservation obligations of
+§4 and §5.
+
+Copyright (C) 2024-2026 Petr Mironychev
+===============================================================
+
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 

LLMClientInterface.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "LLMClientInterface.hpp"
 
@@ -8,27 +9,47 @@
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 
+#include <projectexplorer/project.h>
+#include <projectexplorer/projectmanager.h>
+#include <utils/filepath.h>
+
+#include <Agent.hpp>
+#include <AgentConfig.hpp>
+#include <AgentFactory.hpp>
+#include <AgentRouter.hpp>
+#include <ConversationHistory.hpp>
+#include <PluginBlocks.hpp>
+#include <Session.hpp>
+#include <SessionManager.hpp>
+#include <SystemPromptBuilder.hpp>
+#include "sources/common/ContextData.hpp"
+
+#include <LLMQore/ContentBlocks.hpp>
+
+#include <memory>
+#include <vector>
+
 #include "CodeHandler.hpp"
 #include "context/DocumentContextReader.hpp"
 #include "context/Utils.hpp"
 #include "logger/Logger.hpp"
 #include "settings/CodeCompletionSettings.hpp"
 #include "settings/GeneralSettings.hpp"
-#include <pluginllmcore/RulesLoader.hpp>
+#include "sources/settings/PipelinesConfig.hpp"
 
 namespace QodeAssist {
 
 LLMClientInterface::LLMClientInterface(
     const Settings::GeneralSettings &generalSettings,
     const Settings::CodeCompletionSettings &completeSettings,
-    PluginLLMCore::IProviderRegistry &providerRegistry,
-    PluginLLMCore::IPromptProvider *promptProvider,
+    AgentFactory &agentFactory,
+    SessionManager &sessionManager,
     Context::IDocumentReader &documentReader,
     IRequestPerformanceLogger &performanceLogger)
     : m_generalSettings(generalSettings)
     , m_completeSettings(completeSettings)
-    , m_providerRegistry(providerRegistry)
-    , m_promptProvider(promptProvider)
+    , m_agentFactory(agentFactory)
+    , m_sessionManager(sessionManager)
     , m_documentReader(documentReader)
     , m_performanceLogger(performanceLogger)
     , m_contextManager(new Context::ContextManager(this))
@@ -50,58 +71,56 @@ void LLMClientInterface::startImpl()
     emit started();
 }
 
-void LLMClientInterface::handleFullResponse(const QString &requestId, const QString &fullText)
+void LLMClientInterface::onCompletionFinished(const QString &requestId)
 {
     auto it = m_activeRequests.find(requestId);
     if (it == m_activeRequests.end())
         return;
 
-    const RequestContext &ctx = it.value();
-    sendCompletionToClient(fullText, ctx.originalRequest, true);
+    QString fullText;
+    if (Session *session = it.value().session) {
+        if (auto *history = session->history(); history && !history->isEmpty())
+            fullText = history->messages().back().text();
+    }
+    const QJsonObject originalRequest = it.value().originalRequest;
 
-    m_activeRequests.erase(it);
-    m_performanceLogger.endTimeMeasurement(requestId);
+    sendCompletionToClient(fullText, originalRequest, true);
+    finishRequest(requestId);
 }
 
-void LLMClientInterface::handleRequestFinalized(
-    const ::LLMQore::RequestID &requestId, const ::LLMQore::CompletionInfo &info)
-{
-    if (!m_activeRequests.contains(requestId) || !info.usage)
-        return;
-
-    const auto &u = *info.usage;
-    LOG_MESSAGE(QString("Completion usage [%1]: prompt=%2 completion=%3 cached=%4 reasoning=%5")
-                    .arg(requestId)
-                    .arg(u.promptTokens)
-                    .arg(u.completionTokens)
-                    .arg(u.cachedPromptTokens)
-                    .arg(u.reasoningTokens));
-}
-
-void LLMClientInterface::handleRequestFailed(const QString &requestId, const QString &error)
+void LLMClientInterface::onCompletionFailed(const QString &requestId, const QString &error)
 {
     auto it = m_activeRequests.find(requestId);
     if (it == m_activeRequests.end())
         return;
 
-    const RequestContext &ctx = it.value();
-
     LOG_MESSAGE(QString("Request %1 failed: %2").arg(requestId, error));
 
-    // Send LSP error response to client
     QJsonObject response;
     response["jsonrpc"] = "2.0";
-    response[LanguageServerProtocol::idKey] = ctx.originalRequest["id"];
+    response[LanguageServerProtocol::idKey] = it.value().originalRequest["id"];
 
     QJsonObject errorObject;
     errorObject["code"] = -32603; // Internal error code
     errorObject["message"] = error;
     response["error"] = errorObject;
-    
+
     emit messageReceived(LanguageServerProtocol::JsonRpcMessage(response));
-    
+    finishRequest(requestId);
+}
+
+void LLMClientInterface::finishRequest(const QString &requestId)
+{
+    auto it = m_activeRequests.find(requestId);
+    if (it == m_activeRequests.end())
+        return;
+
+    Session *session = it.value().session;
     m_activeRequests.erase(it);
     m_performanceLogger.endTimeMeasurement(requestId);
+
+    if (session)
+        m_sessionManager.release(session);
 }
 
 void LLMClientInterface::sendData(const QByteArray &data)
@@ -134,26 +153,15 @@ void LLMClientInterface::sendData(const QByteArray &data)
 
 void LLMClientInterface::handleCancelRequest()
 {
-    QSet<PluginLLMCore::Provider *> providers;
-    for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
-        if (it.value().provider) {
-            providers.insert(it.value().provider);
-        }
-    }
-
-    for (auto *provider : providers) {
-        disconnect(provider->client(), nullptr, this, nullptr);
-    }
-
-    for (auto it = m_activeRequests.begin(); it != m_activeRequests.end(); ++it) {
-        const RequestContext &ctx = it.value();
-        if (ctx.provider) {
-            ctx.provider->cancelRequest(it.key());
-        }
-    }
-
+    const auto requests = m_activeRequests;
     m_activeRequests.clear();
 
+    for (auto it = requests.begin(); it != requests.end(); ++it) {
+        m_performanceLogger.endTimeMeasurement(it.key());
+        if (Session *session = it.value().session)
+            m_sessionManager.release(session);
+    }
+
     LOG_MESSAGE("All requests cancelled and state cleared");
 }
 
@@ -236,130 +244,87 @@ void LLMClientInterface::handleCompletion(const QJsonObject &request)
         return;
     }
 
-    auto updatedContext = prepareContext(request, documentInfo);
-
-    bool isPreset1Active = m_contextManager->isSpecifyCompletion(documentInfo);
-
-    const auto providerName = !isPreset1Active ? m_generalSettings.ccProvider()
-                                               : m_generalSettings.ccPreset1Provider();
-    const auto modelName = !isPreset1Active ? m_generalSettings.ccModel()
-                                            : m_generalSettings.ccPreset1Model();
-    const auto url = !isPreset1Active ? m_generalSettings.ccUrl()
-                                      : m_generalSettings.ccPreset1Url();
-
-    const auto provider = m_providerRegistry.getProviderByName(providerName);
-
-    if (!provider) {
-        QString error = QString("No provider found with name: %1").arg(providerName);
+    const QString agentName = pickCompletionAgent(filePath);
+    if (agentName.isEmpty()) {
+        QString error = QString("No code completion agent matches: %1").arg(filePath);
         LOG_MESSAGE(error);
         sendErrorResponse(request, error);
         return;
     }
 
-    auto templateName = !isPreset1Active ? m_generalSettings.ccTemplate()
-                                         : m_generalSettings.ccPreset1Template();
+    QString sessionError;
+    Session *session = m_sessionManager.acquire(agentName, &sessionError);
+    if (!session) {
+        LOG_MESSAGE(sessionError);
+        sendErrorResponse(request, sessionError);
+        return;
+    }
 
-    auto promptTemplate = m_promptProvider->getTemplateByName(templateName);
+    Templates::ContextData context = prepareContext(request, documentInfo);
 
-    if (!promptTemplate) {
-        QString error = QString("No template found with name: %1").arg(templateName);
+    QString editorContext;
+    if (context.fileContext.has_value())
+        editorContext.append(context.fileContext.value());
+
+    if (m_completeSettings.useOpenFilesContext())
+        editorContext.append(m_contextManager->openedFilesContext({filePath}));
+
+    if (!editorContext.isEmpty())
+        session->systemPrompt()->setLayer(QStringLiteral("completion.context"), editorContext);
+
+    connect(session, &Session::finished, this, [this, session](const LLMQore::RequestID &, const QString &) {
+        onCompletionFinished(requestIdForSession(session));
+    });
+    connect(session, &Session::failed, this, [this, session](const LLMQore::RequestID &, const QodeAssist::ErrorInfo &error) {
+        onCompletionFailed(requestIdForSession(session), error.message);
+    });
+
+    if (auto *client = session->client())
+        client->setTransferTimeout(
+            static_cast<int>(m_generalSettings.requestTimeout() * 1000));
+
+    std::vector<std::unique_ptr<LLMQore::ContentBlock>> blocks;
+    blocks.push_back(std::make_unique<CompletionContent>(
+        context.prefix.value_or(QString()), context.suffix.value_or(QString())));
+    const LLMQore::RequestID requestId = session->send(std::move(blocks), /*toolsOverride=*/false);
+    if (requestId.isEmpty()) {
+        QString error = QString("Failed to start completion request for agent '%1': %2")
+                            .arg(agentName, session->lastError().message);
+        session->deleteLater();
         LOG_MESSAGE(error);
         sendErrorResponse(request, error);
         return;
     }
 
-    QJsonObject payload{{"model", modelName}, {"stream", true}};
-
-    const auto stopWords = QJsonArray::fromStringList(promptTemplate->stopWords());
-    if (!stopWords.isEmpty())
-        payload["stop"] = stopWords;
-
-    QString systemPrompt;
-    if (m_completeSettings.useSystemPrompt())
-        systemPrompt.append(
-            m_completeSettings.useUserMessageTemplateForCC()
-                    && promptTemplate->type() == PluginLLMCore::TemplateType::Chat
-                ? m_completeSettings.systemPromptForNonFimModels()
-                : m_completeSettings.systemPrompt());
-
-    auto project = PluginLLMCore::RulesLoader::getActiveProject();
-    if (project) {
-        QString projectRules
-            = PluginLLMCore::RulesLoader::loadRulesForProject(project, PluginLLMCore::RulesContext::Completions);
-
-        if (!projectRules.isEmpty()) {
-            systemPrompt += "\n\n# Project Rules\n\n" + projectRules;
-            LOG_MESSAGE("Loaded project rules for completion");
-        }
-    }
-
-    if (updatedContext.fileContext.has_value())
-        systemPrompt.append(updatedContext.fileContext.value());
-
-    if (m_completeSettings.useOpenFilesContext()) {
-        if (provider->providerID() == PluginLLMCore::ProviderID::LlamaCpp) {
-            for (const auto openedFilePath : m_contextManager->openedFiles({filePath})) {
-                if (!updatedContext.filesMetadata) {
-                    updatedContext.filesMetadata = QList<PluginLLMCore::FileMetadata>();
-                }
-                updatedContext.filesMetadata->append({openedFilePath.first, openedFilePath.second});
-            }
-        } else {
-            systemPrompt.append(m_contextManager->openedFilesContext({filePath}));
-        }
-    }
-
-    updatedContext.systemPrompt = systemPrompt;
-
-    if (promptTemplate->type() == PluginLLMCore::TemplateType::Chat) {
-        QString userMessage;
-        if (m_completeSettings.useUserMessageTemplateForCC()) {
-            userMessage = m_completeSettings.processMessageToFIM(
-                updatedContext.prefix.value_or(""), updatedContext.suffix.value_or(""));
-        } else {
-            userMessage = updatedContext.prefix.value_or("") + updatedContext.suffix.value_or("");
-        }
-
-        // TODO refactor add message
-        QVector<PluginLLMCore::Message> messages;
-        messages.append({"user", userMessage});
-        updatedContext.history = messages;
-    }
-
-    provider->prepareRequest(
-        payload,
-        promptTemplate,
-        updatedContext,
-        PluginLLMCore::RequestType::CodeCompletion,
-        false,
-        false);
-
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::requestCompleted,
-        this,
-        &LLMClientInterface::handleFullResponse,
-        Qt::UniqueConnection);
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::requestFinalized,
-        this,
-        &LLMClientInterface::handleRequestFinalized,
-        Qt::UniqueConnection);
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::requestFailed,
-        this,
-        &LLMClientInterface::handleRequestFailed,
-        Qt::UniqueConnection);
-
-    auto requestId
-        = provider->sendRequest(QUrl(url), payload, resolveEndpoint(promptTemplate, isPreset1Active));
-    m_activeRequests[requestId] = {request, provider};
+    m_activeRequests[requestId] = {request, session};
     m_performanceLogger.startTimeMeasurement(requestId);
 }
 
-PluginLLMCore::ContextData LLMClientInterface::prepareContext(
+QString LLMClientInterface::pickCompletionAgent(const QString &filePath) const
+{
+    const QStringList roster = Settings::PipelinesConfig::load().rosters.codeCompletion;
+    if (roster.isEmpty())
+        return {};
+
+    AgentRouter::Context ctx;
+    ctx.filePath = filePath;
+    if (auto *project = ProjectExplorer::ProjectManager::projectForFile(
+            Utils::FilePath::fromString(filePath)))
+        ctx.projectName = project->displayName();
+
+    return AgentRouter::pickAgent(roster, ctx, m_agentFactory);
+}
+
+QString LLMClientInterface::requestIdForSession(Session *session) const
+{
+    for (auto it = m_activeRequests.cbegin(); it != m_activeRequests.cend(); ++it) {
+        if (it.value().session == session)
+            return it.key();
+    }
+    return {};
+}
+
+Templates::ContextData LLMClientInterface::prepareContext(
     const QJsonObject &request, const Context::DocumentInfo &documentInfo)
 {
     QJsonObject params = request["params"].toObject();
@@ -373,14 +338,6 @@ PluginLLMCore::ContextData LLMClientInterface::prepareContext(
     return reader.prepareContext(lineNumber, cursorPosition, m_completeSettings);
 }
 
-QString LLMClientInterface::resolveEndpoint(
-    PluginLLMCore::PromptTemplate *promptTemplate, bool isLanguageSpecify) const
-{
-    const QString custom = isLanguageSpecify ? m_generalSettings.ccPreset1CustomEndpoint()
-                                             : m_generalSettings.ccCustomEndpoint();
-    return !custom.isEmpty() ? custom : promptTemplate->endpoint();
-}
-
 Context::ContextManager *LLMClientInterface::contextManager() const
 {
     return m_contextManager;
@@ -389,15 +346,6 @@ Context::ContextManager *LLMClientInterface::contextManager() const
 void LLMClientInterface::sendCompletionToClient(
     const QString &completion, const QJsonObject &request, bool isComplete)
 {
-    auto filePath = Context::extractFilePathFromRequest(request);
-    auto documentInfo = m_documentReader.readDocument(filePath);
-    bool isPreset1Active = m_contextManager->isSpecifyCompletion(documentInfo);
-
-    auto templateName = !isPreset1Active ? m_generalSettings.ccTemplate()
-                                         : m_generalSettings.ccPreset1Template();
-
-    auto promptTemplate = m_promptProvider->getTemplateByName(templateName);
-
     QJsonObject position = request["params"].toObject()["doc"].toObject()["position"].toObject();
 
     QJsonObject response;

LLMClientInterface.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
@@ -7,12 +8,11 @@
 #include <languageclient/languageclientinterface.h>
 #include <texteditor/texteditor.h>
 
+#include <QPointer>
+
 #include <context/ContextManager.hpp>
 #include <context/IDocumentReader.hpp>
 #include <context/ProgrammingLanguage.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>
@@ -22,6 +22,14 @@ class QNetworkAccessManager;
 
 namespace QodeAssist {
 
+class AgentFactory;
+class Session;
+class SessionManager;
+
+namespace Templates {
+struct ContextData;
+}
+
 class LLMClientInterface : public LanguageClient::BaseClientInterface
 {
     Q_OBJECT
@@ -30,8 +38,8 @@ public:
     LLMClientInterface(
         const Settings::GeneralSettings &generalSettings,
         const Settings::CodeCompletionSettings &completeSettings,
-        PluginLLMCore::IProviderRegistry &providerRegistry,
-        PluginLLMCore::IPromptProvider *promptProvider,
+        AgentFactory &agentFactory,
+        SessionManager &sessionManager,
         Context::IDocumentReader &documentReader,
         IRequestPerformanceLogger &performanceLogger);
     ~LLMClientInterface() override;
@@ -51,12 +59,6 @@ public:
 protected:
     void startImpl() override;
 
-private slots:
-    void handleFullResponse(const QString &requestId, const QString &fullText);
-    void handleRequestFinalized(
-        const ::LLMQore::RequestID &requestId, const ::LLMQore::CompletionInfo &info);
-    void handleRequestFailed(const QString &requestId, const QString &error);
-
 private:
     void handleInitialize(const QJsonObject &request);
     void handleShutdown(const QJsonObject &request);
@@ -66,22 +68,26 @@ private:
     void handleCancelRequest();
     void sendErrorResponse(const QJsonObject &request, const QString &errorMessage);
 
+    void onCompletionFinished(const QString &requestId);
+    void onCompletionFailed(const QString &requestId, const QString &error);
+    void finishRequest(const QString &requestId);
+    QString requestIdForSession(Session *session) const;
+
     struct RequestContext
     {
         QJsonObject originalRequest;
-        PluginLLMCore::Provider *provider;
+        QPointer<Session> session;
     };
 
-    PluginLLMCore::ContextData prepareContext(
+    Templates::ContextData prepareContext(
         const QJsonObject &request, const Context::DocumentInfo &documentInfo);
 
-    QString resolveEndpoint(
-        PluginLLMCore::PromptTemplate *promptTemplate, bool isLanguageSpecify) const;
+    QString pickCompletionAgent(const QString &filePath) const;
 
     const Settings::CodeCompletionSettings &m_completeSettings;
     const Settings::GeneralSettings &m_generalSettings;
-    PluginLLMCore::IPromptProvider *m_promptProvider = nullptr;
-    PluginLLMCore::IProviderRegistry &m_providerRegistry;
+    AgentFactory &m_agentFactory;
+    SessionManager &m_sessionManager;
     Context::IDocumentReader &m_documentReader;
     IRequestPerformanceLogger &m_performanceLogger;
     QElapsedTimer m_completionTimer;

LLMSuggestion.cpp

@@ -1,6 +1,7 @@
 // Copyright (C) 2023 The Qt Company Ltd.
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "LLMSuggestion.hpp"
 #include <texteditor/texteditor.h>

LLMSuggestion.hpp

@@ -20,6 +20,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
  */
 
 #pragma once

LSPCompletion.hpp

@@ -20,6 +20,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
  */
 
 #pragma once

QodeAssist.json.in

@@ -1,12 +1,12 @@
 {
     "Id" : "qodeassist",
     "Name" : "QodeAssist",
-    "Version" : "0.9.18",
+    "Version" : "0.9.20",
     "CompatVersion" : "${IDE_VERSION}",
     "Vendor" : "Petr Mironychev",
     "VendorId" : "petrmironychev",
     "Copyright" : "(C) ${IDE_COPYRIGHT_YEAR} Petr Mironychev, (C) ${IDE_COPYRIGHT_YEAR} The Qt Company Ltd",
-    "License" : "GPLv3",
+    "License" : "GPLv3 with additional attribution terms (§7b) — see LICENSE",
     "Description": "QodeAssist is an AI-powered coding assistant for Qt Creator. It provides intelligent code completion and suggestions for your code. Prerequisites: Requires one of the supported LLM providers installed (e.g., Ollama or LM Studio) and a compatible large language model downloaded for your chosen provider (e.g., CodeLlama, StarCoder2).",
     "Url" : "https://github.com/Palm1r/QodeAssist",
     "DocumentationUrl" : "https://github.com/Palm1r/QodeAssist",

QodeAssistClient.cpp

@@ -20,6 +20,8 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with QodeAssist. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
  */
 
 #include "QodeAssistClient.hpp"
@@ -157,6 +159,16 @@ QodeAssistClient::QodeAssistClient(LLMClientInterface *clientInterface)
     m_refactorWidgetHandler = new RefactorWidgetHandler(this);
 }
 
+void QodeAssistClient::setSessionManager(SessionManager *sessionManager)
+{
+    m_sessionManager = sessionManager;
+}
+
+void QodeAssistClient::setAgentFactory(AgentFactory *agentFactory)
+{
+    m_agentFactory = agentFactory;
+}
+
 QodeAssistClient::~QodeAssistClient()
 {
     cleanupConnections();
@@ -261,9 +273,8 @@ void QodeAssistClient::requestCompletions(TextEditor::TextEditorWidget *editor)
         return;
 
 
-    if (m_llmClient->contextManager()
-            ->ignoreManager()
-            ->shouldIgnore(editor->textDocument()->filePath().toUrlishString(), project)) {
+    if (m_llmClient->contextManager()->shouldIgnore(
+            editor->textDocument()->filePath().toUrlishString())) {
         LOG_MESSAGE(QString("Ignoring file due to .qodeassistignore: %1")
                         .arg(editor->textDocument()->filePath().toUrlishString()));
         return;
@@ -307,9 +318,8 @@ void QodeAssistClient::requestQuickRefactor(
     if (!isEnabled(project))
         return;
 
-    if (m_llmClient->contextManager()
-            ->ignoreManager()
-            ->shouldIgnore(editor->textDocument()->filePath().toUrlishString(), project)) {
+    if (m_llmClient->contextManager()->shouldIgnore(
+            editor->textDocument()->filePath().toUrlishString())) {
         LOG_MESSAGE(QString("Ignoring file due to .qodeassistignore: %1")
                         .arg(editor->textDocument()->filePath().toUrlishString()));
         return;
@@ -317,6 +327,8 @@ void QodeAssistClient::requestQuickRefactor(
 
     if (!m_refactorHandler) {
         m_refactorHandler = new QuickRefactorHandler(this);
+        m_refactorHandler->setSessionManager(m_sessionManager);
+        m_refactorHandler->setAgentFactory(m_agentFactory);
         connect(
             m_refactorHandler,
             &QuickRefactorHandler::refactoringCompleted,

QodeAssistClient.hpp

@@ -1,10 +1,12 @@
 // Copyright (C) 2023 The Qt Company Ltd.
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
 #include <QObject>
+#include <QPointer>
 
 #include "LLMClientInterface.hpp"
 #include "LSPCompletion.hpp"
@@ -15,11 +17,12 @@
 #include "widgets/EditorChatButtonHandler.hpp"
 #include "widgets/RefactorWidgetHandler.hpp"
 #include <languageclient/client.h>
-#include <pluginllmcore/IPromptProvider.hpp>
-#include <pluginllmcore/IProviderRegistry.hpp>
 
 namespace QodeAssist {
 
+class SessionManager;
+class AgentFactory;
+
 class QodeAssistClient : public LanguageClient::Client
 {
     Q_OBJECT
@@ -27,6 +30,9 @@ public:
     explicit QodeAssistClient(LLMClientInterface *clientInterface);
     ~QodeAssistClient() override;
 
+    void setSessionManager(SessionManager *sessionManager);
+    void setAgentFactory(AgentFactory *agentFactory);
+
     void openDocument(TextEditor::TextDocument *document) override;
     bool canOpenProject(ProjectExplorer::Project *project) override;
 
@@ -67,6 +73,8 @@ private:
     RefactorSuggestionHoverHandler *m_refactorHoverHandler{nullptr};
     RefactorWidgetHandler *m_refactorWidgetHandler{nullptr};
     LLMClientInterface *m_llmClient;
+    SessionManager *m_sessionManager{nullptr};
+    AgentFactory *m_agentFactory{nullptr};
 };
 
 } // namespace QodeAssist

QodeAssistConstants.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

QodeAssisttr.h

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

QuickRefactorHandler.cpp

@@ -1,26 +1,43 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "QuickRefactorHandler.hpp"
 
+#include <memory>
+
 #include <LLMQore/BaseClient.hpp>
+#include <LLMQore/ContentBlocks.hpp>
+#include <LLMQore/ToolsManager.hpp>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QUuid>
 
+#include <projectexplorer/project.h>
+#include <projectexplorer/projectmanager.h>
+#include <utils/filepath.h>
+
 #include <context/DocumentContextReader.hpp>
-#include <pluginllmcore/ResponseCleaner.hpp>
 #include <context/DocumentReaderQtCreator.hpp>
 #include <context/Utils.hpp>
-#include <pluginllmcore/PromptTemplateManager.hpp>
-#include <pluginllmcore/ProvidersManager.hpp>
-#include <pluginllmcore/RulesLoader.hpp>
 #include <logger/Logger.hpp>
-#include <settings/ChatAssistantSettings.hpp>
+#include <sources/common/ResponseCleaner.hpp>
 #include <settings/GeneralSettings.hpp>
 #include <settings/QuickRefactorSettings.hpp>
 #include <settings/ToolsSettings.hpp>
 
+#include "sources/common/ContextData.hpp"
+
+#include <AgentFactory.hpp>
+#include <AgentRouter.hpp>
+#include <ConversationHistory.hpp>
+#include <Session.hpp>
+#include <SessionManager.hpp>
+#include <SystemPromptBuilder.hpp>
+
+#include "sources/settings/PipelinesConfig.hpp"
+#include "tools/ToolsRegistration.hpp"
+
 namespace QodeAssist {
 
 QuickRefactorHandler::QuickRefactorHandler(QObject *parent)
@@ -33,6 +50,16 @@ QuickRefactorHandler::QuickRefactorHandler(QObject *parent)
 
 QuickRefactorHandler::~QuickRefactorHandler() {}
 
+void QuickRefactorHandler::setSessionManager(SessionManager *sessionManager)
+{
+    m_sessionManager = sessionManager;
+}
+
+void QuickRefactorHandler::setAgentFactory(AgentFactory *agentFactory)
+{
+    m_agentFactory = agentFactory;
+}
+
 void QuickRefactorHandler::sendRefactorRequest(
     TextEditor::TextEditorWidget *editor, const QString &instructions)
 {
@@ -87,102 +114,109 @@ void QuickRefactorHandler::sendRefactorRequest(
     prepareAndSendRequest(editor, instructions, range);
 }
 
+QString QuickRefactorHandler::pickRefactorAgent(const QString &filePath) const
+{
+    const QStringList roster = Settings::PipelinesConfig::load().rosters.quickRefactor;
+    if (roster.isEmpty() || !m_agentFactory)
+        return {};
+
+    AgentRouter::Context ctx;
+    ctx.filePath = filePath;
+    if (auto *project = ProjectExplorer::ProjectManager::projectForFile(
+            Utils::FilePath::fromString(filePath)))
+        ctx.projectName = project->displayName();
+
+    return AgentRouter::pickAgent(roster, ctx, *m_agentFactory);
+}
+
 void QuickRefactorHandler::prepareAndSendRequest(
     TextEditor::TextEditorWidget *editor,
     const QString &instructions,
     const Utils::Text::Range &range)
 {
-    auto &settings = Settings::generalSettings();
-
-    auto &providerRegistry = PluginLLMCore::ProvidersManager::instance();
-    auto &promptManager = PluginLLMCore::PromptTemplateManager::instance();
-
-    const auto providerName = settings.qrProvider();
-    auto provider = providerRegistry.getProviderByName(providerName);
-
-    if (!provider) {
-        QString error = QString("No provider found with name: %1").arg(providerName);
+    const auto emitError = [this, editor](const QString &error) {
         LOG_MESSAGE(error);
         RefactorResult result;
         result.success = false;
         result.errorMessage = error;
         result.editor = editor;
         emit refactoringCompleted(result);
+    };
+
+    if (!m_sessionManager) {
+        emitError(QStringLiteral("Quick refactor session manager is not available"));
         return;
     }
 
-    const auto templateName = settings.qrTemplate();
-    auto promptTemplate = promptManager.getChatTemplateByName(templateName);
-
-    if (!promptTemplate) {
-        QString error = QString("No template found with name: %1").arg(templateName);
-        LOG_MESSAGE(error);
-        RefactorResult result;
-        result.success = false;
-        result.errorMessage = error;
-        result.editor = editor;
-        emit refactoringCompleted(result);
+    const QString filePath = editor->textDocument()->filePath().toUrlishString();
+    const QString agentName = pickRefactorAgent(filePath);
+    if (agentName.isEmpty()) {
+        emitError(QStringLiteral("No quick refactor agent matches: %1").arg(filePath));
         return;
     }
 
-    QJsonObject payload{
-        {"model", Settings::generalSettings().qrModel()}, {"stream", true}};
+    QString sessionError;
+    Session *session = m_sessionManager->acquire(agentName, &sessionError);
+    if (!session) {
+        emitError(sessionError.isEmpty() ? QStringLiteral("No quick refactor agent selected")
+                                         : sessionError);
+        return;
+    }
 
-    PluginLLMCore::ContextData context = prepareContext(editor, range, instructions);
+    auto *client = session->client();
+    if (!client) {
+        m_sessionManager->removeSession(session);
+        emitError(QStringLiteral("Quick refactor agent has no live client"));
+        return;
+    }
 
-    bool enableTools = Settings::quickRefactorSettings().useTools();
-    bool enableThinking = Settings::quickRefactorSettings().useThinking();
-    provider->prepareRequest(
-        payload,
-        promptTemplate,
-        context,
-        PluginLLMCore::RequestType::QuickRefactoring,
-        enableTools,
-        enableThinking);
+    const bool enableTools = Settings::quickRefactorSettings().useTools();
+    if (enableTools) {
+        m_sessionManager->toolContributors().contribute(client->tools());
+        client->setMaxToolContinuations(Settings::toolsSettings().maxToolContinuations());
+    }
 
-    provider->client()->setMaxToolContinuations(
-        Settings::toolsSettings().maxToolContinuations());
+    session->systemPrompt()->setLayer(
+        QStringLiteral("refactor"), buildSystemPrompt(editor, range));
+
+    client->setTransferTimeout(
+        static_cast<int>(Settings::generalSettings().requestTimeout() * 1000));
 
     m_isRefactoringInProgress = true;
 
     connect(
-        provider->client(),
-        &::LLMQore::BaseClient::requestCompleted,
-        this,
-        &QuickRefactorHandler::handleFullResponse,
-        Qt::UniqueConnection);
-
+        session, &Session::finished, this,
+        [this](const LLMQore::RequestID &id, const QString &) { onRefactorFinished(id); });
     connect(
-        provider->client(),
-        &::LLMQore::BaseClient::requestFinalized,
-        this,
-        &QuickRefactorHandler::handleRequestFinalized,
-        Qt::UniqueConnection);
+        session, &Session::failed, this,
+        [this](const LLMQore::RequestID &id, const QodeAssist::ErrorInfo &error) {
+            onRefactorFailed(id, error);
+        });
 
-    connect(
-        provider->client(),
-        &::LLMQore::BaseClient::requestFailed,
-        this,
-        &QuickRefactorHandler::handleRequestFailed,
-        Qt::UniqueConnection);
+    std::vector<std::unique_ptr<LLMQore::ContentBlock>> blocks;
+    const QString userMessage = instructions.isEmpty()
+        ? QStringLiteral("Refactor the code to improve its quality and maintainability.")
+        : instructions;
+    blocks.push_back(std::make_unique<LLMQore::TextContent>(userMessage));
+
+    const LLMQore::RequestID requestId = session->send(std::move(blocks), enableTools);
+    if (requestId.isEmpty()) {
+        m_isRefactoringInProgress = false;
+        const QString reason = session->lastError().message;
+        m_sessionManager->removeSession(session);
+        emitError(QStringLiteral("Failed to start quick refactor request for agent '%1': %2")
+                      .arg(agentName, reason));
+        return;
+    }
 
-    const QString customEndpoint = Settings::generalSettings().qrCustomEndpoint();
-    const QString endpoint = !customEndpoint.isEmpty() ? customEndpoint
-                                                       : promptTemplate->endpoint();
-    auto requestId
-        = provider->sendRequest(QUrl(Settings::generalSettings().qrUrl()), payload, endpoint);
     m_lastRequestId = requestId;
-    QJsonObject request{{"id", requestId}};
-
-    m_activeRequests[requestId] = {request, provider};
+    m_activeRequests[requestId] = {QJsonObject{{"id", requestId}}, session};
 }
 
-PluginLLMCore::ContextData QuickRefactorHandler::prepareContext(
-    TextEditor::TextEditorWidget *editor,
-    const Utils::Text::Range &range,
-    const QString &instructions)
+QString QuickRefactorHandler::buildSystemPrompt(
+    TextEditor::TextEditorWidget *editor, const Utils::Text::Range &range)
 {
-    PluginLLMCore::ContextData context;
+    Q_UNUSED(range)
 
     auto textDocument = editor->textDocument();
     Context::DocumentReaderQtCreator documentReader;
@@ -190,7 +224,7 @@ PluginLLMCore::ContextData QuickRefactorHandler::prepareContext(
 
     if (!documentInfo.document) {
         LOG_MESSAGE("Error: Document is not available");
-        return context;
+        return Settings::quickRefactorSettings().systemPrompt();
     }
 
     QTextCursor cursor = editor->textCursor();
@@ -266,17 +300,6 @@ PluginLLMCore::ContextData QuickRefactorHandler::prepareContext(
 
     QString systemPrompt = Settings::quickRefactorSettings().systemPrompt();
 
-    auto project = PluginLLMCore::RulesLoader::getActiveProject();
-    if (project) {
-        QString projectRules = PluginLLMCore::RulesLoader::loadRulesForProject(
-            project, PluginLLMCore::RulesContext::QuickRefactor);
-
-        if (!projectRules.isEmpty()) {
-            systemPrompt += "\n\n# Project Rules\n\n" + projectRules;
-            LOG_MESSAGE("Loaded project rules for quick refactor");
-        }
-    }
-
     systemPrompt += "\n\nFile information:";
     systemPrompt += "\nLanguage: " + documentInfo.mimeType;
     systemPrompt += "\nFile path: " + documentInfo.filePath;
@@ -290,7 +313,7 @@ PluginLLMCore::ContextData QuickRefactorHandler::prepareContext(
           "\n- Your output will completely replace the selected code"
         : "\n- Generate ONLY the code that should be INSERTED at the <cursor> position"
           "\n- Your output will be inserted at the cursor location";
-    
+
     systemPrompt += "\n\n## Formatting Rules:"
                     "\n- Output ONLY the code itself, without ANY explanations or descriptions"
                     "\n- Do NOT include markdown code blocks (no ```, no language tags)"
@@ -298,9 +321,9 @@ PluginLLMCore::ContextData QuickRefactorHandler::prepareContext(
                     "\n- Do NOT repeat existing code, be precise with context"
                     "\n- Do NOT send in answer <cursor> or </cursor> and other tags"
                     "\n- The output must be ready to insert directly into the editor as-is";
-    
+
     systemPrompt += "\n\n## Indentation and Whitespace:";
-    
+
     if (cursor.hasSelection()) {
         QTextBlock startBlock = documentInfo.document->findBlock(cursor.selectionStart());
         int leadingSpaces = 0;
@@ -332,7 +355,7 @@ PluginLLMCore::ContextData QuickRefactorHandler::prepareContext(
                                .arg(leadingSpaces);
         }
     }
-    
+
     systemPrompt += "\n- Use the same indentation style (spaces or tabs) as the surrounding code"
                     "\n- Maintain consistent indentation for nested blocks"
                     "\n- Do NOT remove or reduce the base indentation level"
@@ -345,42 +368,7 @@ PluginLLMCore::ContextData QuickRefactorHandler::prepareContext(
         systemPrompt += "\n\n" + m_contextManager.openedFilesContext({documentInfo.filePath});
     }
 
-    context.systemPrompt = systemPrompt;
-
-    QVector<PluginLLMCore::Message> messages;
-    messages.append(
-        {"user",
-         instructions.isEmpty() ? "Refactor the code to improve its quality and maintainability."
-                                : instructions});
-    context.history = messages;
-
-    return context;
-}
-
-void QuickRefactorHandler::handleLLMResponse(
-    const QString &response, const QJsonObject &request, bool isComplete)
-{
-    if (request["id"].toString() != m_lastRequestId) {
-        return;
-    }
-
-    if (isComplete) {
-        m_isRefactoringInProgress = false;
-        QString cleanedResponse = PluginLLMCore::ResponseCleaner::clean(response);
-
-        RefactorResult result;
-        result.newText = cleanedResponse;
-        result.insertRange = m_currentRange;
-        result.success = true;
-        result.editor = m_currentEditor;
-
-        LOG_MESSAGE("Refactoring completed successfully. New code to insert: ");
-        LOG_MESSAGE("---------- BEGIN REFACTORED CODE ----------");
-        LOG_MESSAGE(cleanedResponse);
-        LOG_MESSAGE("----------- END REFACTORED CODE -----------");
-
-        emit refactoringCompleted(result);
-    }
+    return systemPrompt;
 }
 
 void QuickRefactorHandler::cancelRequest()
@@ -394,10 +382,10 @@ void QuickRefactorHandler::cancelRequest()
 
     auto it = m_activeRequests.find(id);
     if (it != m_activeRequests.end()) {
-        auto provider = it.value().provider;
+        Session *session = it.value().session;
         m_activeRequests.erase(it);
-        if (provider)
-            provider->cancelRequest(id);
+        if (session && m_sessionManager)
+            m_sessionManager->release(session);
     }
 
     RefactorResult result;
@@ -406,42 +394,66 @@ void QuickRefactorHandler::cancelRequest()
     emit refactoringCompleted(result);
 }
 
-void QuickRefactorHandler::handleFullResponse(const QString &requestId, const QString &fullText)
+void QuickRefactorHandler::onRefactorFinished(const QString &requestId)
 {
-    if (requestId == m_lastRequestId) {
-        m_activeRequests.remove(requestId);
-        QJsonObject request{{"id", requestId}};
-        handleLLMResponse(fullText, request, true);
-    }
-}
-
-void QuickRefactorHandler::handleRequestFinalized(
-    const ::LLMQore::RequestID &requestId, const ::LLMQore::CompletionInfo &info)
-{
-    if (requestId != m_lastRequestId || !info.usage)
+    if (requestId != m_lastRequestId)
         return;
 
-    const auto &u = *info.usage;
-    LOG_MESSAGE(
-        QString("Quick refactor usage [%1]: prompt=%2 completion=%3 cached=%4 reasoning=%5")
-            .arg(requestId)
-            .arg(u.promptTokens)
-            .arg(u.completionTokens)
-            .arg(u.cachedPromptTokens)
-            .arg(u.reasoningTokens));
+    auto it = m_activeRequests.find(requestId);
+    Session *session = (it != m_activeRequests.end()) ? it.value().session.data() : nullptr;
+    if (it != m_activeRequests.end())
+        m_activeRequests.erase(it);
+
+    QString fullText;
+    if (session) {
+        if (auto *history = session->history(); history && !history->isEmpty())
+            fullText = history->messages().back().text();
+    }
+
+    m_isRefactoringInProgress = false;
+    m_lastRequestId.clear();
+
+    const QString cleanedResponse = ResponseCleaner::clean(fullText);
+
+    RefactorResult result;
+    result.newText = cleanedResponse;
+    result.insertRange = m_currentRange;
+    result.success = true;
+    result.editor = m_currentEditor;
+
+    LOG_MESSAGE("Refactoring completed successfully. New code to insert: ");
+    LOG_MESSAGE("---------- BEGIN REFACTORED CODE ----------");
+    LOG_MESSAGE(cleanedResponse);
+    LOG_MESSAGE("----------- END REFACTORED CODE -----------");
+
+    emit refactoringCompleted(result);
+
+    if (session && m_sessionManager)
+        m_sessionManager->release(session);
 }
 
-void QuickRefactorHandler::handleRequestFailed(const QString &requestId, const QString &error)
+void QuickRefactorHandler::onRefactorFailed(
+    const QString &requestId, const QodeAssist::ErrorInfo &error)
 {
-    if (requestId == m_lastRequestId) {
-        m_activeRequests.remove(requestId);
-        m_isRefactoringInProgress = false;
-        RefactorResult result;
-        result.success = false;
-        result.errorMessage = error;
-        result.editor = m_currentEditor;
-        emit refactoringCompleted(result);
-    }
+    if (requestId != m_lastRequestId)
+        return;
+
+    auto it = m_activeRequests.find(requestId);
+    Session *session = (it != m_activeRequests.end()) ? it.value().session.data() : nullptr;
+    if (it != m_activeRequests.end())
+        m_activeRequests.erase(it);
+
+    m_isRefactoringInProgress = false;
+    m_lastRequestId.clear();
+
+    RefactorResult result;
+    result.success = false;
+    result.errorMessage = error.message;
+    result.editor = m_currentEditor;
+    emit refactoringCompleted(result);
+
+    if (session && m_sessionManager)
+        m_sessionManager->release(session);
 }
 
 } // namespace QodeAssist

QuickRefactorHandler.hpp

@@ -1,22 +1,27 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 
 #include <QJsonObject>
 #include <QObject>
+#include <QPointer>
 
 #include <LLMQore/BaseClient.hpp>
 #include <texteditor/texteditor.h>
 #include <utils/textutils.h>
 
+#include <ErrorInfo.hpp>
 #include <context/ContextManager.hpp>
 #include <context/IDocumentReader.hpp>
-#include <pluginllmcore/ContextData.hpp>
-#include <pluginllmcore/Provider.hpp>
 
 namespace QodeAssist {
 
+class SessionManager;
+class Session;
+class AgentFactory;
+
 struct RefactorResult
 {
     QString newText;
@@ -34,6 +39,9 @@ public:
     explicit QuickRefactorHandler(QObject *parent = nullptr);
     ~QuickRefactorHandler() override;
 
+    void setSessionManager(SessionManager *sessionManager);
+    void setAgentFactory(AgentFactory *agentFactory);
+
     void sendRefactorRequest(TextEditor::TextEditorWidget *editor, const QString &instructions);
 
     void cancelRequest();
@@ -42,30 +50,26 @@ public:
 signals:
     void refactoringCompleted(const QodeAssist::RefactorResult &result);
 
-private slots:
-    void handleFullResponse(const QString &requestId, const QString &fullText);
-    void handleRequestFinalized(
-        const ::LLMQore::RequestID &requestId, const ::LLMQore::CompletionInfo &info);
-    void handleRequestFailed(const QString &requestId, const QString &error);
-
 private:
     void prepareAndSendRequest(
         TextEditor::TextEditorWidget *editor,
         const QString &instructions,
         const Utils::Text::Range &range);
 
-    void handleLLMResponse(const QString &response, const QJsonObject &request, bool isComplete);
-    PluginLLMCore::ContextData prepareContext(
-        TextEditor::TextEditorWidget *editor,
-        const Utils::Text::Range &range,
-        const QString &instructions);
+    void onRefactorFinished(const QString &requestId);
+    void onRefactorFailed(const QString &requestId, const QodeAssist::ErrorInfo &error);
+    QString buildSystemPrompt(
+        TextEditor::TextEditorWidget *editor, const Utils::Text::Range &range);
+    QString pickRefactorAgent(const QString &filePath) const;
 
     struct RequestContext
     {
         QJsonObject originalRequest;
-        PluginLLMCore::Provider *provider;
+        QPointer<Session> session;
     };
 
+    QPointer<SessionManager> m_sessionManager;
+    QPointer<AgentFactory> m_agentFactory;
     QHash<QString, RequestContext> m_activeRequests;
     TextEditor::TextEditorWidget *m_currentEditor;
     Utils::Text::Range m_currentRange;

README.md

@@ -216,9 +216,9 @@ For optimal coding assistance, we recommend using these top-tier models:
 
 ### Additional Configuration
 
+- **[Creating and Extending Agents](docs/creating-agents.md)** - Add custom agents or override bundled ones with TOML profiles
 - **[Agent Roles](docs/agent-roles.md)** - Create AI personas with specialized system prompts
 - **[Chat Summarization](docs/chat-summarization.md)** - Compress conversations to save context tokens
-- **[Project Rules](docs/project-rules.md)** - Customize AI behavior for your project
 - **[Ignoring Files](docs/ignoring-files.md)** - Exclude files from context using `.qodeassistignore`
 
 ## Features
@@ -473,7 +473,7 @@ QodeAssist uses a flexible prompt composition system that adapts to different co
 - **Custom Instructions** provide reusable templates that can be augmented with specific details
 - **Tool Calling** is available for Chat and Quick Refactor when enabled
 
-See [Project Rules Documentation](docs/project-rules.md), [Agent Roles Guide](docs/agent-roles.md), and [Quick Refactoring Guide](docs/quick-refactoring.md) for more details.
+See [Agent Roles Guide](docs/agent-roles.md) and [Quick Refactoring Guide](docs/quick-refactoring.md) for more details.
 
 ## QtCreator Version Compatibility
 
@@ -532,7 +532,7 @@ If you find QodeAssist helpful, there are several ways you can support the proje
 
 1. **Report Issues**: If you encounter any bugs or have suggestions for improvements, please [open an issue](https://github.com/Palm1r/qodeassist/issues) on our GitHub repository.
 
-2. **Contribute**: Feel free to submit pull requests with bug fixes or new features.
+2. **Contribute**: Feel free to submit pull requests with bug fixes or new features. The easiest contribution is an agent preset for a provider or model you use — it's a single TOML file, no C++ required; see [Contributing your agent](docs/creating-agents.md#contributing-your-agent-to-qodeassist).
 
 3. **Spread the Word**: Star our GitHub repository and share QodeAssist with your fellow developers.
 
@@ -580,6 +580,10 @@ cmake --build .
 
 ## For Contributors
 
+### Adding an agent preset
+
+New provider/model presets are plain TOML — extend a provider base, register the file in `agents.qrc`, and the test suite validates it automatically. Step-by-step guide: [docs/creating-agents.md](docs/creating-agents.md#contributing-your-agent-to-qodeassist).
+
 ### Code Style
 
 - **QML**: Follow [QML Coding Guide](https://github.com/Furkanzmc/QML-Coding-Guide) by @Furkanzmc
@@ -590,6 +594,45 @@ cmake --build .
 
 For detailed development guidelines, architecture patterns, and best practices, see the [project workspace rules](.cursor/rules.mdc).
 
+## License
+
+QodeAssist is licensed under the **GNU General Public License v3.0**
+(see [`LICENSE`](LICENSE)), with **additional attribution terms under
+GPLv3 Section 7(b)**.
+
+You are free to use, modify, and redistribute QodeAssist under GPL-3.0,
+but you **must preserve** the original author attribution, copyright
+notices, and project identification — including in source file headers,
+the plugin metadata (`QodeAssist.json.in`), and the About dialog or
+equivalent user-facing identification. Modified versions must be clearly
+marked as different from the original.
+
+### Commercial licensing
+
+QodeAssist is also available under a separate commercial license for use
+in proprietary or closed-source products without GPL-3.0 obligations.
+For commercial licensing inquiries, contact **palm1r-github-dev@pm.me**.
+
+### Qt Creator components and attributions
+
+QodeAssist is a plugin for Qt Creator and incorporates certain components
+(plugin templates, API headers, and related boilerplate) originating from
+Qt Creator, which are copyright (C) The Qt Company Ltd.
+
+These components are provided by The Qt Company under the GNU General
+Public License version 3, annotated with **The Qt Company GPL Exception
+1.0**. This exception permits the development and distribution of Qt
+Creator plugins under licenses of the plugin author's own choosing,
+notwithstanding the GPL's general linking requirements. It is this
+exception that allows QodeAssist to be offered under both GPL-3.0 and a
+separate commercial license.
+
+The original copyright and license notices of The Qt Company are
+preserved in the relevant source files and must not be removed.
+
+For Qt Creator's licensing terms, see
+[LICENSE.GPL3-EXCEPT](https://github.com/qt-creator/qt-creator/blob/master/LICENSES/LICENSE.GPL3-EXCEPT).
+
 ![qodeassist-icon](https://github.com/user-attachments/assets/dc336712-83cb-440d-8761-8d0a31de898d)
 ![qodeassist-icon-small](https://github.com/user-attachments/assets/8ec241bf-3186-452e-b8db-8d70543c2f41)
 

RefactorContextHelper.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

RefactorSuggestion.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "RefactorSuggestion.hpp"
 #include "LLMSuggestion.hpp"

RefactorSuggestion.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2024-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

RefactorSuggestionHoverHandler.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "RefactorSuggestionHoverHandler.hpp"
 #include "RefactorSuggestion.hpp"

RefactorSuggestionHoverHandler.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

TaskFlow/Editor/FlowEditor.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "FlowEditor.hpp"
 

TaskFlow/Editor/FlowEditor.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

TaskFlow/Editor/FlowItem.cpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #include "FlowItem.hpp"
 
 namespace QodeAssist::TaskFlow {

TaskFlow/Editor/FlowItem.hpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #pragma once
 
 #include <QQuickItem>

TaskFlow/Editor/FlowsModel.cpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #include "FlowsModel.hpp"
 
 #include "FlowManager.hpp"

TaskFlow/Editor/FlowsModel.hpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #pragma once
 
 #include <QAbstractListModel>

TaskFlow/Editor/GridBackground.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #include "GridBackground.hpp"
 #include <QPainter>

TaskFlow/Editor/GridBackground.hpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2025-2026 Petr Mironychev
 // SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
 
 #pragma once
 

TaskFlow/Editor/TaskConnectionItem.cpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #include "TaskConnectionItem.hpp"
 #include "TaskItem.hpp"
 #include "TaskPortItem.hpp"

TaskFlow/Editor/TaskConnectionItem.hpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #pragma once
 
 #include "TaskConnection.hpp"

TaskFlow/Editor/TaskConnectionsModel.cpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #include "TaskConnectionsModel.hpp"
 
 namespace QodeAssist::TaskFlow {

TaskFlow/Editor/TaskConnectionsModel.hpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #pragma once
 
 #include <QAbstractListModel>

TaskFlow/Editor/TaskItem.cpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #include "TaskItem.hpp"
 
 namespace QodeAssist::TaskFlow {

TaskFlow/Editor/TaskItem.hpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #pragma once
 
 #include <QQuickItem>

TaskFlow/Editor/TaskModel.cpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #include "TaskModel.hpp"
 
 namespace QodeAssist::TaskFlow {

TaskFlow/Editor/TaskModel.hpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #pragma once
 
 #include <QAbstractListModel>

TaskFlow/Editor/TaskPortItem.cpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #include "TaskPortItem.hpp"
 
 namespace QodeAssist::TaskFlow {

TaskFlow/Editor/TaskPortItem.hpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #pragma once
 
 #include <TaskPort.hpp>

TaskFlow/Editor/TaskPortModel.cpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2025-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Additional attribution terms under GPLv3 §7(b) apply — see LICENSE
+
 #include "TaskPortModel.hpp"
 #include "TaskPort.hpp"