grammar_source.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/types/config.h>
#include <entropic/types/generation_result.h>
 
#include <string>
 
namespace entropic {
 
enum class GrammarSource {
    none,       
    request,    
 
    tier,
 
    tool_call,  
 
    count,
};
 
inline constexpr int grammar_source_count() {
    return static_cast<int>(GrammarSource::count);
}
 
inline GrammarSource resolve_grammar_source(const std::string& request_grammar,
                                            const std::string& tool_grammar,
                                            bool request_from_tier = false) {
    GrammarSource source = GrammarSource::none;
    if (!request_grammar.empty()) {
        source = request_from_tier ? GrammarSource::tier
                                   : GrammarSource::request;
    } else if (!tool_grammar.empty()) {
        source = GrammarSource::tool_call;
    }
    return source;
}
 
inline bool is_request_grammar(GrammarSource source) {
    return source == GrammarSource::request || source == GrammarSource::tier;
}
 
inline bool tier_grammar_unresolved(const GenerationParams& params) {
    return params.grammar.empty()
        && params.grammar_from_tier
        && !params.resolved_grammar_key.empty();
}
 
inline const char* grammar_source_name(GrammarSource source) {
    const char* name = "none";
    if (source == GrammarSource::request) {
        name = "request";
    } else if (source == GrammarSource::tier) {
        name = "tier";
    } else if (source == GrammarSource::tool_call) {
        name = "tool_call";
    }
    return name;
}
 
inline bool grammar_sources_collide(const std::string& request_grammar,
                                    const std::string& tool_grammar) {
    return !request_grammar.empty() && !tool_grammar.empty();
}
 
inline GrammarProvenance describe_grammar(const GenerationParams& params,
                                          const std::string& tool_grammar) {
    const auto source = resolve_grammar_source(
        params.grammar, tool_grammar, params.grammar_from_tier);
    GrammarProvenance provenance;
    provenance.source = grammar_source_name(source);
    provenance.key = params.resolved_grammar_key;
    provenance.resolved = (source != GrammarSource::none);
    if (!provenance.resolved && !provenance.key.empty()) {
        provenance.source = params.grammar_from_tier
            ? grammar_source_name(GrammarSource::tier)
            : grammar_source_name(GrammarSource::request);
    }
    if (grammar_sources_collide(params.grammar, tool_grammar)) {
        provenance.conflict_winner = provenance.source;
    }
    return provenance;
}
 
} // namespace entropic