types.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 ForestHub. All rights reserved.
// For commercial licensing, visit https://github.com/ForestHubAI/fh-sdk
 
#ifndef FORESTHUB_CORE_TYPES_HPP
#define FORESTHUB_CORE_TYPES_HPP

 
#include <memory>
#include <string>
#include <vector>
 
#include "foresthub/core/input.hpp"
#include "foresthub/core/model.hpp"
#include "foresthub/core/options.hpp"
#include "foresthub/core/tools.hpp"
#include "foresthub/util/json.hpp"
#include "foresthub/util/optional.hpp"
#include "foresthub/util/schema.hpp"
 
namespace foresthub {
namespace core {
 
using json = nlohmann::json;

using FileID = std::string;

struct ResponseFormat {
    std::string name;         
    json schema;              
    std::string description;  
};

struct ChatRequest {
    ModelID model;                                        
    std::shared_ptr<Input> input;                         
    std::string system_prompt;                            
    std::string previous_response_id;                     
    foresthub::Optional<ResponseFormat> response_format;  
    std::vector<std::shared_ptr<Tool>> tools;             
    std::vector<FileID> file_ids;                         
    std::vector<FileID> image_ids;                        
    std::vector<std::string> image_urls;                  
    Options options;                                      

    ChatRequest() = default;

    ChatRequest(ModelID model, std::shared_ptr<Input> input) : model(std::move(model)), input(std::move(input)) {}
 
    // Builder methods for fluent configuration.

    ChatRequest& WithSystemPrompt(std::string prompt) {
        system_prompt = std::move(prompt);
        return *this;
    }

    ChatRequest& WithPreviousResponseId(std::string id) {
        previous_response_id = std::move(id);
        return *this;
    }

    ChatRequest& WithResponseFormat(ResponseFormat format) {
        format.schema = util::NormalizeSchema(std::move(format.schema));
        response_format = std::move(format);
        return *this;
    }

    ChatRequest& AddTool(std::shared_ptr<Tool> tool) {
        tools.push_back(std::move(tool));
        return *this;
    }

    ChatRequest& AddFileId(FileID file_id) {
        file_ids.push_back(std::move(file_id));
        return *this;
    }

    ChatRequest& AddImageId(FileID image_id) {
        image_ids.push_back(std::move(image_id));
        return *this;
    }

    ChatRequest& AddImageUrl(std::string url) {
        image_urls.push_back(std::move(url));
        return *this;
    }

    ChatRequest& WithTemperature(float temperature) {
        options.WithTemperature(temperature);
        return *this;
    }

    ChatRequest& WithMaxTokens(int max_tokens) {
        options.WithMaxTokens(max_tokens);
        return *this;
    }

    ChatRequest& WithTopK(int top_k) {
        options.WithTopK(top_k);
        return *this;
    }

    ChatRequest& WithTopP(float top_p) {
        options.WithTopP(top_p);
        return *this;
    }

    ChatRequest& WithFrequencyPenalty(float frequency_penalty) {
        options.WithFrequencyPenalty(frequency_penalty);
        return *this;
    }

    ChatRequest& WithPresencePenalty(float presence_penalty) {
        options.WithPresencePenalty(presence_penalty);
        return *this;
    }

    ChatRequest& WithSeed(int seed) {
        options.WithSeed(seed);
        return *this;
    }
};

struct ChatResponse {
    std::string text;                                             
    std::vector<std::shared_ptr<InternalToolCall>> tools_called;  
    std::vector<ToolCallRequest> tool_call_requests;              
    std::string response_id;                                      
    int tokens_used = 0;                                          
};
 
}  // namespace core
}  // namespace foresthub
 
#endif  // FORESTHUB_CORE_TYPES_HPP