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_;
    bool streaming_{false};
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& values) const;
    nim_cpp_wrapper_util::Json::Value ToJsonValue() const;
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIMessageRAGInfo {
    std::string name_;
    std::string description_;
    std::string icon_;
    std::string url_;
    std::string title_;
    time_t time_{0};
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& values) const {
        values[kNIMAICallKeyAIRAGName] = name_;
        values[kNIMAICallKeyAIRAGIcon] = icon_;
        values[kNIMAICallKeyAIRAGUrl] = url_;
        values[kNIMAICallKeyAIRAGTitle] = title_;
        values[kNIMAICallKeyAIRAGTime] = static_cast<int64_t>(time_);
        values[kNIMAICallKeyAIRAGDescription] = description_;
    }
    void FromJsonValue(const nim_cpp_wrapper_util::Json::Value& values) {
        if (values.isMember(kNIMAICallKeyAIRAGName))
            name_ = values[kNIMAICallKeyAIRAGName].asString();
        if (values.isMember(kNIMAICallKeyAIRAGIcon))
            icon_ = values[kNIMAICallKeyAIRAGIcon].asString();
        if (values.isMember(kNIMAICallKeyAIRAGUrl))
            url_ = values[kNIMAICallKeyAIRAGUrl].asString();
        if (values.isMember(kNIMAICallKeyAIRAGTitle))
            title_ = values[kNIMAICallKeyAIRAGTitle].asString();
        if (values.isMember(kNIMAICallKeyAIRAGTime))
            time_ = values[kNIMAICallKeyAIRAGTime].asInt64();
        if (values.isMember(kNIMAICallKeyAIRAGDescription))
            description_ = values[kNIMAICallKeyAIRAGDescription].asString();
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIModelCallResult {
    std::string account_id_;
    std::string request_id_;
    NIMAIModelCallContent content_;
    std::list<NIMAIMessageRAGInfo> rags_;
    time_t timestamp_{0};
    bool streaming_{false};
    NIMAIStreamingMessageStatus streaming_message_status_{kNIMAIStreamingMessageNone};
    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();
        }
        if (values.isMember(kNIMAICallKeyAIRAGs) && values[kNIMAICallKeyAIRAGs].isArray()) {
            for (const auto& rag : values[kNIMAICallKeyAIRAGs]) {
                NIMAIMessageRAGInfo rag_info;
                rag_info.FromJsonValue(rag);
                rags_.push_back(rag_info);
            }
        }
        if (values.isMember(kNIMAICallKeyContentKeyTimestamp))
            timestamp_ = values[kNIMAICallKeyContentKeyTimestamp].asInt64();
        if (values.isMember(kNIMAICallKeyStreaming))
            streaming_ = values[kNIMAICallKeyStreaming].asBool();
        if (values.isMember(kNIMAICallKeyStreamingMessageStatus))
            streaming_message_status_ = static_cast<NIMAIStreamingMessageStatus>(values[kNIMAICallKeyStreamingMessageStatus].asInt());
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIModelStreamingCallChunk {
    std::string content_;
    time_t chunk_time_{0};
    int type_{0};
    uint32_t index_{0};
    void ToJsonValue(nim_cpp_wrapper_util::Json::Value& values) const {
        values[kNIMAICallKeyStreamingMessageChunkContent] = content_;
        values[kNIMAICallKeyStreamingMessageChunkChunkTime] = static_cast<int64_t>(chunk_time_);
        values[kNIMAICallKeyStreamingMessageChunkType] = type_;
        values[kNIMAICallKeyStreamingMessageChunkIndex] = index_;
    }
    void FromJsonValue(const nim_cpp_wrapper_util::Json::Value& values) {
        if (values.isMember(kNIMAICallKeyStreamingMessageChunkContent))
            content_ = values[kNIMAICallKeyStreamingMessageChunkContent].asString();
        if (values.isMember(kNIMAICallKeyStreamingMessageChunkChunkTime))
            chunk_time_ = values[kNIMAICallKeyStreamingMessageChunkChunkTime].asInt64();
        if (values.isMember(kNIMAICallKeyStreamingMessageChunkType))
            type_ = values[kNIMAICallKeyStreamingMessageChunkType].asInt();
        if (values.isMember(kNIMAICallKeyStreamingMessageChunkIndex))
            index_ = values[kNIMAICallKeyStreamingMessageChunkIndex].asUInt();
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIModelStreamingCallContent {
    std::string message_;
    int type_{0};
    NIMAIModelStreamingCallChunk chunk_;
    void FromJsonValue(const nim_cpp_wrapper_util::Json::Value& values) {
        if (values.isMember(kNIMAICallKeyContentKeyMsg))
            message_ = values[kNIMAICallKeyContentKeyMsg].asString();
        if (values.isMember(kNIMAICallKeyContentKeyType))
            type_ = values[kNIMAICallKeyContentKeyType].asInt();
        if (values.isMember(kNIMAICallKeyStreamingMessageChunk)) {
            chunk_.FromJsonValue(values[kNIMAICallKeyStreamingMessageChunk]);
        }
    }
};
 
struct NIM_SDK_CPPWRAPPER_DLL_API NIMAIModelStreamingCallResult {
    NIMResCode code_{kNIMResSuccess};
    std::string account_id_;
    std::string request_id_;
    NIMAIModelStreamingCallContent content_;
    std::list<NIMAIMessageRAGInfo> rags_;
    time_t timestamp_{0};
    void FromJsonValue(const nim_cpp_wrapper_util::Json::Value& values) {
        if (values.isMember(kNIMResCode))
            code_ = static_cast<NIMResCode>(values[kNIMResCode].asInt());
        if (values.isMember(kNIMAICallKeyAccountID))
            account_id_ = values[kNIMAICallKeyAccountID].asString();
        if (values.isMember(kNIMAICallKeyRequestID))
            request_id_ = values[kNIMAICallKeyRequestID].asString();
        if (values.isMember(kNIMAICallKeyContent))
            content_.FromJsonValue(values[kNIMAICallKeyContent]);
        if (values.isMember(kNIMAICallKeyAIRAGs) && values[kNIMAICallKeyAIRAGs].isArray()) {
            for (const auto& rag : values[kNIMAICallKeyAIRAGs]) {
                NIMAIMessageRAGInfo rag_info;
                rag_info.FromJsonValue(rag);
                rags_.push_back(rag_info);
            }
        }
        if (values.isMember(kNIMMsgKeyTime))
            timestamp_ = values[kNIMMsgKeyTime].asInt64();
    }
};
 
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