refactor: Move to agent-session architecture

sources/providers/CMakeLists.txt

@@ -2,6 +2,7 @@ add_library(Providers STATIC
     ProviderID.hpp
     Provider.hpp Provider.cpp
     ProviderFactory.hpp ProviderFactory.cpp
+    GenericProvider.hpp GenericProvider.cpp
 )
 
 target_link_libraries(Providers

sources/providers/GenericProvider.cpp

@@ -0,0 +1,113 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "GenericProvider.hpp"
+
+#include <utility>
+
+#include <LLMQore/BaseClient.hpp>
+#include <LLMQore/ClaudeClient.hpp>
+#include <LLMQore/GoogleAIClient.hpp>
+#include <LLMQore/LlamaCppClient.hpp>
+#include <LLMQore/MistralClient.hpp>
+#include <LLMQore/OllamaClient.hpp>
+#include <LLMQore/OpenAIClient.hpp>
+#include <LLMQore/OpenAIResponsesClient.hpp>
+
+#include "ProviderFactory.hpp"
+
+namespace QodeAssist::Providers {
+
+GenericProvider::GenericProvider(
+    QString name,
+    ProviderID id,
+    ProviderCapabilities capabilities,
+    const ClientFactory &clientFactory,
+    QObject *parent)
+    : Provider(parent)
+    , m_name(std::move(name))
+    , m_id(id)
+    , m_capabilities(capabilities)
+    , m_client(clientFactory(this))
+{}
+
+QString GenericProvider::name() const
+{
+    return m_name;
+}
+
+ProviderID GenericProvider::providerID() const
+{
+    return m_id;
+}
+
+ProviderCapabilities GenericProvider::capabilities() const
+{
+    return m_capabilities;
+}
+
+::LLMQore::BaseClient *GenericProvider::client() const
+{
+    return m_client;
+}
+
+QFuture<QList<QString>> GenericProvider::getInstalledModels(const QString &url)
+{
+    m_client->setUrl(url);
+    m_client->setApiKey(apiKey());
+    return m_client->listModels();
+}
+
+namespace {
+
+using Cap = ProviderCapability;
+
+template<typename ClientT>
+GenericProvider::ClientFactory makeFactory()
+{
+    return [](QObject *parent) -> ::LLMQore::BaseClient * {
+        return new ClientT(QString(), QString(), QString(), parent);
+    };
+}
+
+} // namespace
+
+void registerBuiltinProviders()
+{
+    const auto reg = [](const QString &api,
+                        ProviderID id,
+                        ProviderCapabilities caps,
+                        GenericProvider::ClientFactory factory) {
+        ProviderFactory::registerType(api, [=](QObject *parent) -> Provider * {
+            return new GenericProvider(api, id, caps, factory, parent);
+        });
+    };
+
+    const ProviderCapabilities full
+        = Cap::Tools | Cap::Thinking | Cap::Image | Cap::ModelListing;
+
+    reg("Claude", ProviderID::Claude, full, makeFactory<::LLMQore::ClaudeClient>());
+    reg("Google AI", ProviderID::GoogleAI, full, makeFactory<::LLMQore::GoogleAIClient>());
+    reg("llama.cpp", ProviderID::LlamaCpp, full, makeFactory<::LLMQore::LlamaCppClient>());
+    reg("LM Studio (Chat Completions)", ProviderID::LMStudio, full,
+        makeFactory<::LLMQore::OpenAIClient>());
+    reg("LM Studio (Responses API)", ProviderID::OpenAIResponses, full,
+        makeFactory<::LLMQore::OpenAIResponsesClient>());
+    reg("Mistral AI", ProviderID::MistralAI, full, makeFactory<::LLMQore::MistralClient>());
+    reg("Codestral", ProviderID::MistralAI, Cap::Tools | Cap::Image,
+        makeFactory<::LLMQore::MistralClient>());
+    reg("Ollama (Native)", ProviderID::Ollama, full, makeFactory<::LLMQore::OllamaClient>());
+    reg("Ollama (OpenAI-compatible)", ProviderID::OpenAICompatible, full,
+        makeFactory<::LLMQore::OpenAIClient>());
+    reg("OpenAI (Chat Completions)", ProviderID::OpenAI, full,
+        makeFactory<::LLMQore::OpenAIClient>());
+    reg("OpenAI (Responses API)", ProviderID::OpenAIResponses, full,
+        makeFactory<::LLMQore::OpenAIResponsesClient>());
+    reg("OpenAI Compatible", ProviderID::OpenAICompatible,
+        Cap::Tools | Cap::Image | Cap::Thinking, makeFactory<::LLMQore::OpenAIClient>());
+    reg("OpenRouter", ProviderID::OpenRouter,
+        Cap::Tools | Cap::Image | Cap::Thinking | Cap::ModelListing,
+        makeFactory<::LLMQore::OpenAIClient>());
+}
+
+} // namespace QodeAssist::Providers

sources/providers/GenericProvider.hpp

@@ -0,0 +1,50 @@
+// Copyright (C) 2024-2026 Petr Mironychev
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <functional>
+
+#include "Provider.hpp"
+
+namespace LLMQore {
+class BaseClient;
+}
+
+namespace QodeAssist::Providers {
+
+// A configuration-driven provider: it owns an LLMQore client and exposes a
+// fixed identity/capability set. Concrete behaviour (request shape) comes from
+// the agent's prompt template via Provider::prepareRequest, so a single class
+// covers every client_api by varying the client factory + metadata.
+class GenericProvider : public Provider
+{
+    Q_OBJECT
+public:
+    using ClientFactory = std::function<::LLMQore::BaseClient *(QObject *)>;
+
+    GenericProvider(
+        QString name,
+        ProviderID id,
+        ProviderCapabilities capabilities,
+        const ClientFactory &clientFactory,
+        QObject *parent = nullptr);
+
+    QString name() const override;
+    QFuture<QList<QString>> getInstalledModels(const QString &url) override;
+    ProviderID providerID() const override;
+    ProviderCapabilities capabilities() const override;
+    ::LLMQore::BaseClient *client() const override;
+
+private:
+    QString m_name;
+    ProviderID m_id;
+    ProviderCapabilities m_capabilities;
+    ::LLMQore::BaseClient *m_client;
+};
+
+// Registers every built-in client_api into ProviderFactory. Must be called once
+// at plugin startup before any agent/session is created.
+void registerBuiltinProviders();
+
+} // namespace QodeAssist::Providers