generation_result.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/types/error.h>
#include <entropic/types/tool_call.h>
 
#include <string>
#include <vector>
 
namespace entropic {
 
struct GrammarProvenance {
    std::string source = "none";
 
    std::string key;
 
    bool resolved = false;
 
    std::string conflict_winner;
};
 
struct GenerationResult {
    std::string content;                   
    std::string raw_content;               
    std::vector<ToolCall> tool_calls;       
    std::string finish_reason = "stop";    
    int token_count = 0;                   
    double generation_time_ms = 0.0;       
 
    int prefill_tokens = 0;
 
    /* ── Orchestrator timing (populated by ModelOrchestrator) ── */
    double routing_ms = 0.0;               
    double swap_ms = 0.0;                  
    double total_ms = 0.0;                 
 
    /* ── v1.9.7: Throughput + time cap metadata ── */
 
    double throughput_tok_s = 0.0;
 
    bool time_limited = false;
 
    int original_max_tokens = 0;
 
    /* ── v1.9.13: Multi-sequence tracking ── */
 
    int seq_id = 0;
 
    /* ── gh#36 / gh#106: speculative-decode observability ── */
 
    int n_drafted = 0;
 
    int n_accepted = 0;
 
    /* ── gh#154: grammar provenance ── */
 
    GrammarProvenance grammar;
 
    /* ── Error state (for partial results on failure) ── */
    entropic_error_t error_code = ENTROPIC_OK; 
    std::string error_message;              
 
    bool ok() const { return error_code == ENTROPIC_OK; }
};
 
struct GenerationRecord {
    std::string finish_reason;        
    int token_count = 0;              
    int prefill_tokens = 0;           
    double throughput_tok_s = 0.0;    
    int n_drafted = 0;                
    int n_accepted = 0;               
    GrammarProvenance grammar;        
};
 
inline GenerationRecord make_generation_record(const GenerationResult& r) {
    GenerationRecord rec;
    rec.finish_reason = r.finish_reason;
    rec.token_count = r.token_count;
    rec.prefill_tokens = r.prefill_tokens;
    rec.throughput_tok_s = r.throughput_tok_s;
    rec.n_drafted = r.n_drafted;
    rec.n_accepted = r.n_accepted;
    rec.grammar = r.grammar;
    return rec;
}
 
} // namespace entropic