package main

import (
    "encoding/base64"
    "fmt"
    "os"
    "time"

    "github.com/volcengine/volcengine-go-sdk/service/llmshield"
)

func EncodeImageToBase64(imagePath string) (string, error) {
    // 读取图片文件内容
    data, err := os.ReadFile(imagePath)
    if err != nil {
        return "", fmt.Errorf("读取图片失败: %v", err)
    }

    // 进行Base64编码
    base64Str := base64.StdEncoding.EncodeToString(data)
    return base64Str, nil
}


func main() {
    var response *llmshield.ModerateV2Response
    var err error
    myUrl := "https://cn-shanghai.sdk.access.llm-shield.omini-shield.com" // 实例所在地域的服务接口地址
    ak := "YOUR AK"               // Access Key，用于身份认证
    sk := "YOUR SK"               // Secret Key，用于身份认证
    appid := "app-****"            // 应用ID，标识要使用的审核应用
    region := "cn-shanghai"             // 实例所在地域

    timeout := time.Second * 60 // 超时时间
    request := llmshield.ModerateV2Request{
        Message: nil,
        Scene:   appid,
    }


    dtstr, err := EncodeImageToBase64("/Users/DeepFakeTest/image_001.png") // 待检测图片的本地存储路径
    dsize := len(dtstr)
    // 确保图片大小不超过 10 MB
    if err != nil || dsize > 1010241024 {
        fmt.Printf("%v,dsize:%v", err, dsize)
        return
    }
    request.Message = &llmshield.MessageV2{
        Content:     dtstr,
        ContentType: llmshield.ContentTypeV2_IMAGE,
        Role:        "user",
    }


    // 创建客户端实例
    client := llmshield.New(myUrl, ak, sk, region, timeout)
    if client == nil {
        fmt.Printf("Failed to create client instance
")
        return
    }
    response, err = client.Moderate(&request)
    if err != nil {
        fmt.Printf("Error occurred while checking LLM response stream: %v
", err)
    }
    if response == nil {
        fmt.Println("Received empty result")
    }
    fmt.Printf("Received result: %s
", response.String())
}

import sys
from volcenginesdkllmshield import *
import base64


def load_file_content(file_type, file_path):
    with open(file_path, 'rb') as f:
        file_bytes = f.read()


    baseStr = base64.b64encode(file_bytes).decode('utf-8')
    if file_type == "mp4":
        baseStr = "data:video/mp4;base64," + baseStr
    elif file_type == "avi":
        baseStr = "data:video/avi;base64," + baseStr
    print(f"", baseStr)
    return baseStr


def main():
    # 配置信息（请替换为实际值）
    myUrl = "https://cn-shanghai.sdk.access.llm-shield.omini-shield.com" # 根据大模型应用防火墙实例所在地域替换相应的地域信息
    ak = "YOUR AK"  # 火山账号的 AK
    sk = "YOUR SK"  # 火山账号的 SK
    appid = "app-****" # 资产的 AppId，可在控制台资产管理页面获取
    region = "cn-shanghai" # 大模型应用防火墙实例所在地域


    TIMEOUT = 50  # 超时时间（秒）


    try:
        # 发送请求并获取响应
        client = ClientV2(myUrl, ak, sk, region, TIMEOUT)
        
        # 构建请求
        request = ModerateV2Request(
            scene = appid,  # 资产的 AppId
            message = MessageV2(
                role = "user",  # 检测的内容来源，user-用户提示词；assistant-模型响应内容
                content = load_file_content("mp4", "/Users/DeepFakeTest/video_001.mp4"),  # 需要检测的视频格式和本地路径
                content_type = ContentTypeV2.VIDEO #内容类型，文本-TEXT，文件-FILE，图片-IMAGE，音频-AUDIO，视频-VIDEO
            ),
        )


        response = client.Moderate(request)


        # 使用 pydantic 的内置序列化方法
        print("审核结果（JSON格式）:")
        print(response.model_dump_json(by_alias=True, indent=2))  # pydantic 模型直接转 JSON


    except Exception as e:
        print(f"请求失败: {e}")


if __name__ == "__main__":
    main() 

package main

import (
    "encoding/base64"
    "fmt"
    "os"
    "strings"
    "time"

    "github.com/volcengine/volcengine-go-sdk/service/llmshield"
)

var (
    role      = "user"       // 待检测内容来源，user-用户输入，assistant-模型输出
    datainfo1 = "/Users/DeepFakeTest/video_001.mp4" // 待检测内容的路径
    dataMap   = map[string]*DcInfo{

        datainfo1: {"mp4", llmshield.ContentTypeV2_VIDEO},
    }
)

func main() {
    var response *llmshield.ModerateV2Response
    var err error
    ak := "YOUR AK"     // 火山账号的 AK
    sk := "YOUR SK"  // 火山账号的 SK
    appid := "app-****"      // 资产的 AppId，可在控制台资产管理页面获取
    region := "cn-shanghai"      // 大模型应用防火墙实例所在地域
    myUrl := "https://cn-shanghai.sdk.access.llm-shield.omini-shield.com" // 大模型应用防火墙实例的访问地址，根据地域替换
    timeout := time.Second * 20            // 超时时间
    // 创建客户端实例
    client := llmshield.New(myUrl, ak, sk, region, timeout)
    if client == nil {
        fmt.Printf("Failed to create client instance
")
        return
    }
    request := llmshield.ModerateV2Request{Message: nil, Scene: appid}
    request.Message = filledMsgContent(role)
    response, err = client.Moderate(&request)
    if err != nil {
        fmt.Printf("Error occurred while checking LLM response stream: %v
", err)
    }
    if response == nil {
        fmt.Println("Received empty result")
    }
    fmt.Printf("Received result: %s
", response.String())
}
func filledMsgContent(role string) *llmshield.MessageV2 {
    var (
        err     error
        content string
    )
    msg_multi := &llmshield.MessageV2{
        Role: role,
    }
    for dataInfo, cGroup := range dataMap {
        switch cGroup.Dtype {
        case llmshield.ContentTypeV2_TEXT:
            content = dataInfo
        case llmshield.ContentTypeV2_IMAGE, llmshield.ContentTypeV2_FILE, llmshield.ContentTypeV2_AUDIO, llmshield.ContentTypeV2_VIDEO:
            content, err = encodeFileToBase64(cGroup.ftype, dataInfo)
            if err != nil {
                fmt.Printf("Failed to encode file content:%v,err:%v
", content, err)
            }
        }
        multPart := &llmshield.MultiPart{
            Content:     content,
            ContentType: cGroup.Dtype,
        }
        msg_multi.MultiPart = append(msg_multi.MultiPart, multPart)
    }
    return msg_multi
}
func encodeFileToBase64(ftype string, filePath string) (string, error) {
    data, err := os.ReadFile(filePath)
    if err != nil {
        return "", fmt.Errorf("读取文件失败: %v", err)
    }
    base64Str := base64.StdEncoding.EncodeToString(data)
    // 根据文件类型添加 data URI 头
    switch strings.ToLower(ftype) {
    case "mp4":
        base64Str = "data:video/mp4;base64," + base64Str
    case "avi":
        base64Str = "data:video/x-msvideo;base64," + base64Str
    }
    if len(base64Str) > 50 {
        fmt.Printf("Headfile: %v
", strings.Split(base64Str[:50], "base64,")[0])
    }
    return base64Str, nil
}


type DcInfo struct {
    ftype string
    Dtype llmshield.ContentTypeV2
}

{
  "ResponseMetadata": {
    "RequestId": "02177937606464100000000000000000000ffff0a1600e81****",
    "Action": "Moderate",
    "Version": "2025-08-31",
    "Service": "llmshield",
    "Region": "cn-shanghai",
    "HTTPCode": 200,
    "Error": null
  },
  "Result": {
    "MsgID": "abe4e699287c4b699729c0f47a53****",
    "RiskInfo": {
      "Risks": null
    },
    "Decision": {
      "DecisionType": 1,
      "DecisionDetail": {
        "BlockDetail": {},
        "ReplaceDetail": {
          "Replacement": null
        }
      }
    },
    "PermitInfo": {
      "Permits": null
    },
    "ContentInfo": "jpg",
    "Degraded": false,
    "DegradeReason": ""
  }
}