tool_executor.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/core/directives.h>
#include <entropic/core/engine_types.h>
#include <entropic/mcp/mcp_authorization.h>
#include <entropic/mcp/server_manager.h>
#include <entropic/mcp/tool_call_history.h>
#include <entropic/types/tool_result.h>
 
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace entropic {
 
/* ToolExecutorHooks moved to engine_types.h — v2.0.2 */
 
struct PreconditionCheck {
    std::optional<Message> rejection;   
    ToolResultKind kind = ToolResultKind::ok;  
};
 
class ToolExecutor {
public:
    ToolExecutor(ServerManager& server_manager,
                 const LoopConfig& loop_config,
                 EngineCallbacks& callbacks,
                 ToolExecutorHooks hooks = {});
 
    void set_permission_persist(const PermissionPersistInterface& persist);
 
    void set_server_resolver(
        ServerManager* (*fn)(const std::string& session_key, void* user_data),
        void* user_data);
 
    void set_tier_allowed_tools(
        const std::unordered_map<std::string,
                                 std::vector<std::string>>* map) {
        tier_allowed_tools_ = map;
    }
 
    std::vector<Message> process_tool_calls(
        LoopContext& ctx,
        const std::vector<ToolCall>& tool_calls);
 
private:
    static std::vector<ToolCall> sort_tool_calls(
        const std::vector<ToolCall>& calls);
 
    void extract_and_process_directives(
        LoopContext& ctx, const std::string& raw_result);
 
    std::string check_duplicate(const LoopContext& ctx,
                                const ToolCall& call) const;
 
    Message handle_duplicate(LoopContext& ctx,
                             const ToolCall& call,
                             const std::string& previous_result);
 
    bool check_approval(const ToolCall& call);
 
    std::optional<Message> check_tier_allowed(
        const LoopContext& ctx, const ToolCall& call) const;
 
    std::pair<Message, std::string> execute_tool(
        LoopContext& ctx, const ToolCall& call);
 
    void record_tool_history(const ToolCall& call,
                             const std::string& args_json,
                             const std::string& result_text,
                             long long ms, int iteration);
 
    void finalize_tool_call(LoopContext& ctx, const ToolCall& call,
                            Message& msg, const std::string& raw_result,
                            double exec_ms);
 
    void log_tool_call(LoopContext& ctx, const ToolCall& call,
                       double exec_ms, const std::string& raw_result,
                       ToolResultKind kind);
 
    static std::string tool_call_key(const ToolCall& call);
 
    void record_tool_call(LoopContext& ctx,
                          const ToolCall& call,
                          const std::string& result);
 
    static Message create_denied_message(const ToolCall& call,
                                         const std::string& reason);
 
    static Message create_error_message(const ToolCall& call,
                                        const std::string& error);
 
    void fire_state_callback(const LoopContext& ctx);
 
    void truncate_to_limit(std::vector<ToolCall>& calls, int limit) const;
 
    PreconditionCheck check_call_preconditions(
        LoopContext& ctx, const ToolCall& call);
 
    PreconditionCheck check_approval_pc(
        LoopContext& ctx, const ToolCall& call);
 
    std::optional<Message> check_schema(const ToolCall& call);
 
    std::optional<Message> check_dup_or_approval(
        LoopContext& ctx, const ToolCall& call);
 
    std::vector<Message> process_single_call(
        LoopContext& ctx, const ToolCall& incoming);
 
    bool should_stop_batch(const LoopContext& ctx,
                           const std::vector<Message>& results) const;
 
    void run_post_tool_hooks(LoopContext& ctx);
 
    static Message create_circuit_breaker_message();
 
    static Message create_duplicate_message(
        const ToolCall& call,
        const std::string& previous_result);
 
    static std::string serialize_args(const ToolCall& call);
 
    static std::string serialize_tool_call(const ToolCall& call);
 
    static std::string build_post_tool_json(
        const ToolCall& call,
        const std::string& raw_result,
        double elapsed_ms,
        const std::string& tier,
        int iteration,
        ToolResultKind kind);
 
    void update_anti_spiral_tracking(LoopContext& ctx,
                                     const std::string& tool_name);
 
    int effective_hard_block_threshold() const;
 
    PreconditionCheck check_anti_spiral_hard_block(
        const LoopContext& ctx, const ToolCall& call) const;
 
    PreconditionCheck check_repeated_failure(
        const LoopContext& ctx, const ToolCall& call) const;
 
    PreconditionCheck check_spiral_blocks(
        const LoopContext& ctx, const ToolCall& call) const;
 
    void apply_result_size_cap(std::string& content) const;
 
    static std::string build_pre_tool_json(
        const ToolCall& call,
        const std::string& tier,
        int iteration);
 
    void fire_post_tool_hook(const LoopContext& ctx,
                             const ToolCall& call,
                             const std::string& raw_result,
                             double elapsed_ms,
                             ToolResultKind kind,
                             Message& msg);
 
    bool fire_pre_tool_hook(const LoopContext& ctx, ToolCall& call);
 
    static bool apply_pre_tool_modification(ToolCall& call,
                                            const char* modified);
 
    void fire_tool_complete_callback(const ToolCall& call,
                                     const std::string& result,
                                     long long ms);
 
    ServerManager& server_manager_;       
    ServerManager* (*server_resolver_)(const std::string&, void*) = nullptr;
    void* server_resolver_data_ = nullptr;   
 
    ServerManager& servers_for(const std::string& session_key) const;
 
    const LoopConfig& loop_config_;       
    EngineCallbacks& callbacks_;          
    ToolExecutorHooks hooks_;             
    PermissionPersistInterface permission_persist_; 
    const std::unordered_map<std::string, std::vector<std::string>>*
        tier_allowed_tools_ = nullptr;
    HookInterface hook_iface_;            
    ToolCallHistory history_{100};        
    std::atomic<size_t> history_seq_{0};  
 
public:
    const ToolCallHistory& tool_history() const { return history_; }
 
    void set_hooks(const HookInterface& hooks) { hook_iface_ = hooks; }
 
    void set_authorization_manager(MCPAuthorizationManager* auth_mgr) {
        auth_mgr_ = auth_mgr;
    }
 
private:
    MCPAuthorizationManager* auth_mgr_ = nullptr; 
 
    std::optional<Message> check_mcp_authorization(
        const LoopContext& ctx,
        const ToolCall& call) const;
};
 
} // namespace entropic