api/api_server.hpp

Orchestrates the full inference pipeline (PTDS §9) More...

Namespaces

Name
sgns
sgns::neoswarm
sgns::neoswarm::network
sgns::neoswarm::api

Classes

	Name
class	sgns::neoswarm::api::ApiServer Orchestrates the full inference pipeline.
struct	sgns::neoswarm::api::ApiServer::Config
struct	sgns::neoswarm::api::ApiServer::Config::ElmEntry

Detailed Description

Orchestrates the full inference pipeline (PTDS §9)

Date: 2026-05-08

Source code

#ifndef NEOSWARM_API_SERVER_HPP
#define NEOSWARM_API_SERVER_HPP

#include "common/error.hpp"
#include "common/types.hpp"
#include "core/engine/inference_engine.hpp"
#include "knowledge/context_injection.hpp"
#include "knowledge/fact_validation.hpp"
#include "knowledge/knowledge_retrieval.hpp"
#include "network/p2p_node.hpp"
#include "network/result_aggregation.hpp"
#include "reputation/reputation_crdt.hpp"
#include "reputation/reputation_scoring.hpp"
#include "reputation/reputation_storage.hpp"
#include "reputation/weighted_consensus.hpp"
#include "router/rule_based_router.hpp"
#include "security/node_identity.hpp"
#include "specialists/grammar_specialist.hpp"
#include "specialists/math_specialist.hpp"
#include "elm/i_elm.hpp"
#include "elm/elm_chain_builder.hpp"
#include "router/prompt_analyzer.hpp"
#include <atomic>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>

namespace sgns::neoswarm::network
{
    class SGClient;
}

namespace sgns::neoswarm::api
{
    class ApiServer
    {
        public:
        struct Config
        {
            std::string m_modelPath;
            std::string m_grammarModelPath;
            std::string m_mathModelPath;
            std::string m_reputationDbPath = "./reputation.db";
            std::string m_knowledgeFacts = "";
            bool m_enableNetwork = false;
            bool m_enableKnowledge = true;
            int m_grpcPort = 50051;
            std::string m_nodeKeyFile = "./node.key";
            std::string m_nodeKeyPassphrase = "gnus-neo-swarm-default";
            bool m_enableSgProcessing = false;
            bool m_sgProcessingNetworkMode = false;
            // SDK data / write directory. Feeds GeniusNodeConfig::BaseWritePath (IN-03).
            // Override per-node via the JSON config file key "sg_base_path" (D-09).
            std::string m_sgSdkBasePath = "./sdk";

            // ELM configuration (Phase 7+)
            struct ElmEntry
            {
                std::string role;     
                std::string model;    
                bool eager = false;   
            };
            std::vector<ElmEntry> m_elmConfigs;
        };

        explicit ApiServer( Config cfg );
        ~ApiServer();

        outcome::result<void> Initialize();

        outcome::result<InferenceResponse> Process( const Task& task );

        outcome::result<void> Serve();

        void Stop();

        bool IsRunning() const
        {
            return m_running.load();
        }

        bool IsSuperGeniusConnected() const noexcept;

        bool IsSuperGeniusNetworkEnabled() const noexcept
        {
            return m_cfg.m_sgProcessingNetworkMode;
        }

        private:
        Config m_cfg;
        std::atomic<bool> m_running{ false };
        std::condition_variable m_stopCondition;
        std::mutex m_stopMutex;

        std::shared_ptr<security::NodeIdentity> m_identity;
        std::shared_ptr<core::InferenceEngine> m_coreEngine;
        std::shared_ptr<specialists::GrammarSpecialist> m_grammarSpec;
        std::shared_ptr<specialists::MathSpecialist> m_mathSpec;
        std::unique_ptr<router::RuleBasedRouter> m_router;
        std::unique_ptr<reputation::WeightedConsensus> m_consensus;
        std::unique_ptr<reputation::ReputationScoring> m_scoring;
        std::unique_ptr<reputation::ReputationStorage> m_repStorage;
        std::unique_ptr<reputation::ReputationCRDT> m_repCrdt;
        std::unique_ptr<network::P2PNode> m_p2pNode;
        std::unique_ptr<network::ResultAggregation> m_aggregation;
        std::shared_ptr<knowledge::KnowledgeRetrieval> m_knowledge;
        std::unique_ptr<knowledge::ContextInjection> m_contextInj;
        std::unique_ptr<knowledge::FactValidation> m_factVal;
        std::unique_ptr<network::SGClient> m_sgClient;

        // ELM subsystem (Phase 7+)
        std::unordered_map<ELMRole, std::shared_ptr<elm::IELM>> m_elmRegistry;
        std::unique_ptr<elm::ELMChainBuilder> m_chainBuilder;
        std::unique_ptr<router::PromptAnalyzer> m_promptAnalyzer;

        outcome::result<InferenceResponse> RunSingleNode( const Task& task, const RouteDecision& route );
        outcome::result<InferenceResponse> RunSpecialist( const Task& task, const RouteDecision& route );
        outcome::result<InferenceResponse> RunSwarm( const Task& task, const RouteDecision& route );
        outcome::result<InferenceResponse> RunELMChain( const Task& task, const RouteDecision& route );

        void InitializeEngine();
        void InitializeNetwork();

        std::string AugmentPrompt( const std::string& prompt, std::vector<KnowledgeFact>& out_facts ) const;

        void UpdateReputation( const InferenceResponse& resp,
                               double median_latency_ms,
                               const std::string& m_consensusoutput );
    };

} // namespace sgns::neoswarm::api

#endif // NEOSWARM_API_SERVER_HPP

---

Updated on 2026-10-09 at 03:59:42 +0000