nim_ai_helper.h

浏览该文件的文档.

 
#ifndef NIM_AI_HELPER_H
#define NIM_AI_HELPER_H
 
#include <functional>
#include <list>
#include <map>
#include <string>
#include "nim_cpp_wrapper/nim_sdk_cpp_wrapper.h"
#include "nim_define_include.h"
#include "nim_user_helper.h"
 
namespace nim {
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIModelCallContent {
    std::string msg_;
    int32_t type_{0};
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIModelCallMessage {
    NIMAIModelRoleType role_{kNIMMessageAIModelRoleTypeSystem};
    std::string msg_;
    int32_t type_{0};
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMProxyAICallAntispamConfig {
    bool antispam_enabled_{true};
    std::string antispam_business_id_;
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& values) const;
    std::string ToJsonString() const;
};
 
enum NIMAIModelConfigFieldFlag {
    kAIModelConfigFieldFlagPrompt = 1,
    kAIModelConfigFieldFlagMaxTokens = 1 << 1,
    kAIModelConfigFieldFlagTopP = 1 << 2,
    kAIModelConfigFieldFlagTemperature = 1 << 3,
    kAIModelConfigFieldFlagModel = 1 << 4,
    kAIModelConfigFieldFlagPromptKeys = 1 << 5,
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIModelConfigBase {
    std::string prompt_;
    int32_t max_tokens_{0};
    float top_p_{0.0};
    float temperature_{0.0};
 
    void SetPrompt(const std::string& prompt) {
        prompt_ = prompt;
        field_valid_flags_ |= kAIModelConfigFieldFlagPrompt;
    }
    std::string GetPrompt() const { return prompt_; }
    void SetMaxTokens(int32_t max_tokens) {
        max_tokens_ = max_tokens;
        field_valid_flags_ |= kAIModelConfigFieldFlagMaxTokens;
    }
    int32_t GetMaxTokens() const { return max_tokens_; }
    void SetTopP(float top_p) {
        top_p_ = top_p;
        field_valid_flags_ |= kAIModelConfigFieldFlagTopP;
    }
    float GetTopP() const { return top_p_; }
    void SetTemperature(float temperature) {
        temperature_ = temperature;
        field_valid_flags_ |= kAIModelConfigFieldFlagTemperature;
    }
    float GetTemperature() const { return temperature_; }
 
    bool ExistValue(NIMAIModelConfigFieldFlag flag) const { return (field_valid_flags_ & flag) != 0; }
 
protected:
    unsigned int field_valid_flags_{0};
};
 
using NIMAIModelConfigParams = NIMAIModelConfigBase;
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIModelCallBase {
    std::string account_id_;
    NIMAIModelCallContent content_;
    std::list<NIMAIModelCallMessage> messages_;
    std::string prompt_variables_;
    NIMAIModelConfigParams model_config_params_;
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& values) const;
    nim_cpp_wrapper_util::Json::Value ToJsonValue() const;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIModelCallResult {
    std::string account_id_;
    std::string request_id_;
    NIMAIModelCallContent content_;
    void FromJsonString(const std::string& json_string) {
        nim_cpp_wrapper_util::Json::Value values;
        ParseJsonValue(json_string, values);
        if (values.isMember(kNIMAICallKeyAccountID))
            account_id_ = values[kNIMAICallKeyAccountID].asString();
        if (values.isMember(kNIMAICallKeyRequestID))
            request_id_ = values[kNIMAICallKeyRequestID].asString();
        if (values.isMember(kNIMAICallKeyContent)) {
            const auto& content = values[kNIMAICallKeyContent];
            if (content.isMember(kNIMAICallKeyContentKeyMsg))
                content_.msg_ = content[kNIMAICallKeyContentKeyMsg].asString();
            if (content.isMember(kNIMAICallKeyContentKeyType))
                content_.type_ = content[kNIMAICallKeyContentKeyType].asInt();
        }
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIModelConfig : NIMAIModelConfigBase {
    std::string model_;
    std::list<std::string> prompt_keys_;
 
    void SetModel(const std::string& model) {
        model_ = model;
        field_valid_flags_ |= kAIModelConfigFieldFlagModel;
    }
    std::string GetModel() const { return model_; }
    void SetPromptKeys(const std::list<std::string>& prompt_keys) {
        prompt_keys_ = prompt_keys;
        field_valid_flags_ |= kAIModelConfigFieldFlagPromptKeys;
    }
    std::list<std::string> GetPromptKeys() const { return prompt_keys_; }
};
 
enum AIUserNameCardFieldFlag {
 
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API AIUserNameCard : UserNameCard {
    NIMAIModelType model_type_;
    NIMAIModelConfig model_config_;
 
    void SetModelType(NIMAIModelType model_type) {
        model_type_ = model_type;
        value_available_flag_ |= kUserNameCardKeyModelType;
    }
    NIMAIModelType GetModelType() const { return model_type_; }
 
    void SetModelConfig(const NIMAIModelConfig& model_config) {
        model_config_ = model_config;
        value_available_flag_ |= kUserNameCardKeyModelConfig;
    }
    NIMAIModelConfig GetModelConfig() const { return model_config_; }
 
    std::string ToJsonString() const;
    nim_cpp_wrapper_util::Json::Value ToJsonObject() const;
};
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseAIUserNameCards(const std::string& namecards_json, std::list<AIUserNameCard>& namecards);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseAIUserNameCards(const nim_cpp_wrapper_util::Json::Value& namecards_json, std::list<AIUserNameCard>& namecards);
 
NIM_SDK_CPPWRAPPER_DLL_API bool ParseAIUserNameCard(const std::string& namecard_json, AIUserNameCard& namecard);
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseAIUserNameCard(const nim_cpp_wrapper_util::Json::Value& namecard_json, AIUserNameCard& namecard);
 
NIM_SDK_CPPWRAPPER_DLL_API void ParseAIUserModelConfig(const nim_cpp_wrapper_util::Json::Value& model_config_json, NIMAIModelConfig& model_config);
 
}  // namespace nim
 
#endif  // NIM_AI_HELPER_H