json_serializers.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/mcp/utf8_sanitize.h>
#include <entropic/types/config.h>
#include <entropic/types/content.h>
#include <entropic/types/message.h>
#include <nlohmann/json.hpp>
#include <cstddef>
#include <string>
#include <vector>
 
namespace facade_json {
 
inline nlohmann::json serialize_content_part(const entropic::ContentPart& p) {
    nlohmann::json j;
    if (p.type == entropic::ContentPartType::IMAGE) {
        j["type"] = "image";
        j["path"] = entropic::mcp::sanitize_utf8(p.image_path);
        j["url"] = entropic::mcp::sanitize_utf8(p.image_url);
        j["width"] = p.width;
        j["height"] = p.height;
    } else {
        j["type"] = "text";
        j["text"] = entropic::mcp::sanitize_utf8(p.text);
    }
    return j;
}
 
inline nlohmann::json serialize_metadata(const entropic::Message& m) {
    nlohmann::json meta = nlohmann::json::object();
    for (const auto& [k, v] : m.metadata) {
        meta[k] = entropic::mcp::sanitize_utf8(v);
    }
    return meta;
}
 
inline nlohmann::json serialize_parts(const entropic::Message& m) {
    nlohmann::json parts = nlohmann::json::array();
    // Indexed rather than a range-for: knots' parser loses this function's
    // closing brace on `for (const auto& p : m.content_parts)` and then
    // charges every following inline in this header to serialize_parts
    // (SLOC 55, ABC 34 for a six-line body). Same class of mis-attribution
    // the comment on LlamaCppBackend::invalidate_resident_kv records. Do not
    // "clean this up" without re-running the complexity gate.
    for (std::size_t i = 0; i < m.content_parts.size(); ++i) {
        parts.push_back(serialize_content_part(m.content_parts[i]));
    }
    return parts;
}
 
inline nlohmann::json serialize_message(const entropic::Message& m) {
    nlohmann::json obj = nlohmann::json::object();
    obj["role"] = m.role;
    obj["content"] = entropic::mcp::sanitize_utf8(m.content);
    if (!m.metadata.empty()) { obj["metadata"] = serialize_metadata(m); }
    if (!m.content_parts.empty()) {
        obj["content_parts"] = serialize_parts(m);
    }
    return obj;
}
 
inline std::string serialize_messages(
    const std::vector<entropic::Message>& messages) {
    nlohmann::json arr = nlohmann::json::array();
    for (const auto& m : messages) {
        arr.push_back(serialize_message(m));
    }
    return arr.dump();
}
 
inline nlohmann::json parse(const char* str) {
    if (!str) { return nlohmann::json(); }
    return nlohmann::json::parse(str, nullptr, false);
}
 
inline nlohmann::json obj() { return nlohmann::json::object(); }
 
inline nlohmann::json arr() { return nlohmann::json::array(); }
 
inline std::string serialize_adapter_info(
    const entropic::AdapterInfo& ai) {
    nlohmann::json j;
    j["name"] = ai.name;
    j["state"] = static_cast<int>(ai.state);
    j["scale"] = ai.scale;
    j["ram_bytes"] = ai.ram_bytes;
    j["path"] = ai.path.string();
    j["tier_name"] = ai.tier_name;
    j["base_model_path"] = ai.base_model_path;
    return j.dump();
}
 
inline std::string serialize_adapter_list(
    const std::vector<entropic::AdapterInfo>& adapters) {
    nlohmann::json a = nlohmann::json::array();
    for (const auto& ai : adapters) {
        a.push_back({{"name", ai.name},
                     {"state", static_cast<int>(ai.state)},
                     {"scale", ai.scale},
                     {"tier_name", ai.tier_name}});
    }
    return a.dump();
}
 
} // namespace facade_json