session.hpp

Go to the documentation of this file.

// Copyright 2026 Aniket Kulkarni
// SPDX-License-Identifier: Apache-2.0
 
 
#pragma once
 
#include "neuralplus/export.hpp"
#include "neuralplus/types.hpp"
 
#include <any>
#include <atomic>
#include <functional>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace neuralplus {
 
class AIClient;
 
class NEURALPLUS_API SessionState final {
public:
    SessionState() = default;
 
    template <typename T>
    void set(std::string key, T value) {
        std::lock_guard<std::mutex> lock(mutex_);
        values_[std::move(key)] = std::move(value);
    }
 
    template <typename T>
    [[nodiscard]] std::optional<T> get(std::string_view key) const {
        std::lock_guard<std::mutex> lock(mutex_);
        const auto iterator = values_.find(std::string(key));
        if (iterator == values_.end()) {
            return std::nullopt;
        }
        const T* value = std::any_cast<T>(&iterator->second);
        if (value == nullptr) {
            throw std::bad_any_cast{};
        }
        return *value;
    }
 
    template <typename T, typename UpdateFunction>
    T update(std::string key, T initial_value, UpdateFunction&& update_function) {
        std::lock_guard<std::mutex> lock(mutex_);
        auto result = values_.try_emplace(std::move(key), std::move(initial_value));
        T* current = std::any_cast<T>(&result.first->second);
        if (current == nullptr) {
            throw std::bad_any_cast{};
        }
        *current = std::invoke(std::forward<UpdateFunction>(update_function), *current);
        return *current;
    }
 
    [[nodiscard]] bool contains(std::string_view key) const;
 
    void erase(std::string_view key);
 
    void clear();
 
private:
    SessionState(const SessionState&) = delete;
    SessionState& operator=(const SessionState&) = delete;
 
    mutable std::mutex mutex_;
    std::unordered_map<std::string, std::any> values_;
};
 
struct SessionOptions {
    std::string id;
 
    std::optional<std::string> system_message;
 
    std::vector<Message> messages;
};
 
class NEURALPLUS_API Session final {
public:
    using Messages = std::vector<Message>;
 
    explicit Session(SessionOptions options = {});
    ~Session();
 
    [[nodiscard]] const std::string& id() const noexcept;
 
    void set_system(std::string message);
 
    [[nodiscard]] std::optional<std::string> system() const;
 
    void append(Message message);
 
    [[nodiscard]] Messages messages() const;
 
    void clear_messages();
 
    [[nodiscard]] SessionState& state() noexcept;
 
    [[nodiscard]] const SessionState& state() const noexcept;
 
private:
    friend class AIClient;
 
    class RunLease final {
    public:
        RunLease(RunLease&& other) noexcept;
        ~RunLease();
 
    private:
        friend class Session;
        explicit RunLease(Session& session) noexcept;
 
        RunLease(const RunLease&) = delete;
        RunLease& operator=(const RunLease&) = delete;
        RunLease& operator=(RunLease&&) = delete;
 
        Session* session_;
    };
 
    [[nodiscard]] RunLease acquire();
    void release() noexcept;
    void append_from_client(Message message);
 
    Session(const Session&) = delete;
    Session& operator=(const Session&) = delete;
 
    std::string id_;
    mutable std::mutex messages_mutex_;
    std::optional<std::string> system_message_;
    Messages messages_;
    SessionState state_;
    std::atomic<bool> active_{false};
};
 
}  // namespace neuralplus