classification.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include <entropic/prompts/classification.h>
#include <entropic/types/logging.h>
#include <algorithm>
#include <cctype>
 
namespace entropic::prompts {
 
namespace {
auto logger = entropic::log::get("prompts.classification");
} // anonymous namespace
 
static std::string to_upper(const std::string& s)
{
    std::string result = s;
    std::transform(result.begin(), result.end(), result.begin(),
                   [](unsigned char c) { return std::toupper(c); });
    return result;
}
 
std::vector<std::string> interleave_examples(
    const std::vector<TierDescriptor>& tiers)
{
    struct Queue {
        int digit;
        const std::vector<std::string>* examples;
    };
 
    std::vector<Queue> queues;
    for (size_t i = 0; i < tiers.size(); ++i) {
        if (!tiers[i].examples.empty()) {
            queues.push_back(
                {static_cast<int>(i + 1), &tiers[i].examples});
        }
    }
 
    std::vector<std::string> lines;
    size_t round_idx = 0;
    while (true) {
        bool added = false;
        for (const auto& q : queues) {
            if (round_idx < q.examples->size()) {
                lines.push_back("\"" + (*q.examples)[round_idx]
                                + "\" -> "
                                + std::to_string(q.digit));
                added = true;
            }
        }
        if (!added) {
            break;
        }
        ++round_idx;
    }
    return lines;
}
 
static std::string join(
    const std::vector<std::string>& items, const std::string& sep)
{
    std::string result;
    for (size_t i = 0; i < items.size(); ++i) {
        if (i > 0) result += sep;
        result += items[i];
    }
    return result;
}
 
static std::string format_tier_definitions(
    const std::vector<TierDescriptor>& tiers)
{
    std::string result;
    for (size_t i = 0; i < tiers.size(); ++i) {
        result += std::to_string(i + 1) + " = "
                  + to_upper(tiers[i].name) + ": "
                  + join(tiers[i].focus, ", ") + "\n";
    }
    return result;
}
 
std::string build_classification_prompt(
    const std::vector<TierDescriptor>& tiers,
    const std::string& message,
    const std::vector<std::string>& history,
    const std::vector<std::string>& recent_tiers)
{
    std::string result = "Classify the message. Reply with the number only.\n\n";
    result += format_tier_definitions(tiers) + "\n";
 
    if (!recent_tiers.empty()) {
        result += "Recent tiers: " + join(recent_tiers, " -> ") + "\n\n";
    }
 
    if (!history.empty()) {
        size_t start = history.size() > 5 ? history.size() - 5 : 0;
        std::vector<std::string> recent(history.begin() + static_cast<long>(start), history.end());
        result += "Recent messages: " + join(recent, " | ") + "\n\n";
    }
 
    for (const auto& line : interleave_examples(tiers)) {
        result += line + "\n";
    }
 
    result += "\"" + message + "\" -> ";
    logger->info("Classification prompt: {} tiers, {} history, "
                 "{} chars",
                 tiers.size(), history.size(), result.size());
    return result;
}
 
} // namespace entropic::prompts