OA2023/OASystem/OASystem.Api/OAMethodLib/KiMiApi/KiMiApi.cs

using OASystem.Domain.Dtos.Groups;
using OASystem.Domain.Dtos.KiMi;
using System.Net.Http.Headers;

namespace OASystem.API.OAMethodLib.KiMiApi
{
    public class KiMiApiClient
    {

        //读取配置文件
        private KiMiSetting _kimiSetting { get; set; }

        private readonly HttpClient _httpClient;

        public KiMiApiClient()
        {
            _httpClient = new HttpClient();

            _kimiSetting = AutofacIocManager.Instance.GetService<KiMiSetting>();

            // 设置公共请求头
            _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _kimiSetting.Key);
        }

        //private  string apiKey = "sk-AY1Sv4rLnSUgGGHcC8SGSWYYKzGID7leZJcFfxAYozLC8dIc";
        //private  string baseUrl = "https://api.moonshot.cn/v1";

        public async Task<string> UploadFileAsync(IFormFile file)
        {
            string message = string.Empty;

            byte[] fileBytes = null;

            using (var memoryStream = new MemoryStream())
            {
                await file.CopyToAsync(memoryStream);
                fileBytes = memoryStream.ToArray();
            }

            // 上传文件
            var fileContent = new ByteArrayContent(fileBytes);

            var fileFormData = new MultipartFormDataContent
            {
                { fileContent, "file", file.FileName },
                { new StringContent("file-extract"), "purpose" }
            };

            HttpResponseMessage fileResponse = await _httpClient.PostAsync($"{_kimiSetting.BaseUrl}/files", fileFormData);
            string fileResponseContent = await fileResponse.Content.ReadAsStringAsync();

            if (!fileResponse.IsSuccessStatusCode)
            {
                throw new Exception($"Failed to upload file: {fileResponseContent}");
            }

            dynamic fileObject = JsonConvert.DeserializeObject(fileResponseContent);
            string fileId = fileObject.id;

            HttpResponseMessage contentResponse = await _httpClient.GetAsync($"{_kimiSetting.BaseUrl}/files/{fileId}/content");
            string fileContentText = await contentResponse.Content.ReadAsStringAsync();

            if (!contentResponse.IsSuccessStatusCode)
            {
                throw new Exception($"Failed to get file content: {fileContentText}");
            }

            message = fileContentText;


            return message;
        }

        public async Task<List<SeedMessages>> UploadFilesAsync(List<IFormFile> files)
        {
            List<SeedMessages> result = new List<SeedMessages>();

            foreach (IFormFile file in files)
            {
                var fileConter = await this.UploadFileAsync(file);
                result.Add(new SeedMessages() { Role = KimiRole.system , Content = fileConter });
            }


            return result;
        }

        public async Task<string> SeedMessage(List<SeedMessages> messages)
        {
            string completionResponseContent = await SeedAsync(messages);
             // 解析返回的完成结果
            var completion = JObject.Parse(completionResponseContent);
            string reply = completion["choices"][0]["message"].ToString();
            return reply;
        }

        public async Task<KiMiRoot> SeedMessageByFullConterObject(List<SeedMessages> messages)
        {
            var respStr =  await SeedAsync(messages);
            return JsonConvert.DeserializeObject<KiMiRoot>(respStr);
        }

        private async Task<string> SeedAsync(List<SeedMessages> messages)
        {
            var completionRequest = new
            {
                model = _kimiSetting.Model,
                messages = messages.Select(x => new
                {
                    Role = StringEnumHelper.ToStringValue(x.Role),
                    x.Content
                }),
                temperature = 1
            };

            var completionJson = JsonConvert.SerializeObject(completionRequest);
            var completionContent = new StringContent(completionJson, Encoding.UTF8, "application/json");

            HttpResponseMessage completionResponse = await _httpClient.PostAsync($"{_kimiSetting.BaseUrl}/chat/completions", completionContent);
            string completionResponseContent = await completionResponse.Content.ReadAsStringAsync();

            if (!completionResponse.IsSuccessStatusCode)
            {
                throw new Exception($"Failed to seed message: {completionResponseContent}");
            }

            return completionResponseContent;
        }
    }

    public class SeedMessages
    {
        public KimiRole Role { get; set; }

        public string Content { get; set; }
    }


    public class KiMiRoot
    {
        public string Id { get; set; }
        public string Object { get; set; }
        public long Created { get; set; }
        public string Model { get; set; }
        public List<Choice> Choices { get; set; }
        public Usage Usage { get; set; }
    }

    public class Choice
    {
        public int Index { get; set; }
        public ReturnMessage Message { get; set; }
        public string FinishReason { get; set; }
    }

    public class Usage
    {
        public int PromptTokens { get; set; }
        public int CompletionTokens { get; set; }
        public int TotalTokens { get; set; }
    }

    public class ReturnMessage
    {
        public string Role { get; set; }
        public string Content { get; set; }
    }

    public enum KimiRole
    {
        system,
        user
    }

    public static class StringEnumHelper
    {
        public static string ToStringValue(KimiRole value)
        {
            return value switch
            {
                KimiRole.system => "system",
                KimiRole.user => "user",
                _ => throw new ArgumentOutOfRangeException(nameof(value), value, null)
            };
        }
    }

}