response_generator.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/core/engine_types.h>
#include <entropic/core/stream_think_filter.h>
#include <entropic/interfaces/i_hook_handler.h>
#include <entropic/interfaces/i_inference_callbacks.h>
 
#include <atomic>
#include <string>
#include <thread>
#include <vector>
 
namespace entropic {
 
struct GenerateResult {
    std::string content;        
    std::string tool_calls_json; 
    std::string finish_reason;  
};
 
class ResponseGenerator {
public:
    ResponseGenerator(const InferenceInterface& inference,
                      const LoopConfig& loop_config,
                      EngineCallbacks& callbacks,
                      GenerationEvents events);
 
    GenerateResult generate_response(LoopContext& ctx);
 
    bool is_response_complete(const std::string& content,
                              const std::string& tool_calls_json);
 
private:
    void lock_tier_if_needed(LoopContext& ctx);
 
    GenerateResult generate_streaming(LoopContext& ctx);
 
    GenerateResult generate_batch(LoopContext& ctx);
 
    int dispatch_batch_generate(
        const std::string& msgs_json,
        const std::string& params_json,
        char** result_json);
 
    std::thread spawn_cancel_poller(int& cancel_int,
                                    std::atomic<bool>& done) const;
 
    std::pair<std::string, std::string> prepare_prompts(
        LoopContext& ctx, const char* mode);
 
    std::string handle_pause(LoopContext& ctx,
                             const std::string& partial);
 
    static std::string serialize_messages(
        const std::vector<Message>& messages);
 
    std::string build_params_json(const std::string& tier,
                                  const std::string& session_key = "");
 
    std::vector<Message> inject_engine_state_reminder(
        const std::vector<Message>& messages,
        const LoopContext& ctx);
 
    InferenceInterface inference_;     
    LoopConfig loop_config_;           
    EngineCallbacks& callbacks_;       
    GenerationEvents events_;          
    HookInterface hooks_;              
    TokenCallback stream_observer_ = nullptr;
    void* stream_observer_data_ = nullptr;
 
    void (*state_observer_)(int, void*) = nullptr;
    void* state_observer_data_ = nullptr;
 
public:
    void set_hooks(const HookInterface& hooks) { hooks_ = hooks; }
 
    void set_stream_observer(TokenCallback observer, void* user_data) {
        stream_observer_ = observer;
        stream_observer_data_ = user_data;
    }
 
    TokenCallback stream_observer() const { return stream_observer_; }
 
    void set_state_observer(
        void (*observer)(int, void*), void* user_data) {
        state_observer_ = observer;
        state_observer_data_ = user_data;
    }
 
    void* stream_observer_data() const { return stream_observer_data_; }
};
 
} // namespace entropic