GPT-3とVoiceVoxを活用してAIエージェントを作る！【Unity】

using System;
using UnityEngine.Windows.Speech;

public class WinSpeechRecognition : IDisposable
{
    private readonly DictationRecognizer _dictationRecognizer;
    public event Action<string, ConfidenceLevel> OnDictationResult;

    public WinSpeechRecognition()
    {
        _dictationRecognizer = new DictationRecognizer();
        _dictationRecognizer.DictationResult += (t, c) => OnDictationResult!(t, c);
    }

    public void Start() => _dictationRecognizer.Start();
    public void Stop() => _dictationRecognizer.Stop();

    public void Dispose()
    {
        _dictationRecognizer?.Stop();
        _dictationRecognizer?.Dispose();
    }
}

_speechRecognition.OnDictationResult += OnDictationResult;

using System;
using System.Collections.Generic;
using System.Text;
using AAA.OpenAI;
using Cysharp.Threading.Tasks;
using UnityEngine;
using UnityEngine.Networking;

public class OpenAIConnection
{
    private string _apiKey;

    public OpenAIConnection(string apiKey)
    {
        _apiKey = apiKey;
    }
    
    public async UniTask<TextCompletionResponseModel> RequestCompletionAsync(string prompt)
    {
        //スクリプトプロパティに設定したOpenAIのAPIキーを取得
        //文章生成AIのAPIのエンドポイントを設定
        var apiUrl = "https://api.openai.com/v1/completions";

        //OpenAIのAPIリクエストに必要なヘッダー情報を設定
        var headers = new Dictionary<string, string>
        {
            {"Authorization", "Bearer " + _apiKey},
            {"Content-type", "application/json"},
            {"X-Slack-No-Retry", "1"}
        };
        //文章生成で利用するモデルやトークン上限、プロンプトをオプションに設定
        var options = new OpenAICompletionRequestModel()
        {
            model = "text-davinci-003",
            max_tokens = 256,
            temperature = 0.9f,
            prompt = prompt
        };
        var jsonOptions = JsonUtility.ToJson(options);
        
        //OpenAIの文章生成(Completion)にAPIリクエストを送り、結果を変数に格納
        using var request = new UnityWebRequest(apiUrl, "POST")
        {
            uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(jsonOptions)),
            downloadHandler = new DownloadHandlerBuffer()
        };

        foreach (var header in headers)
        {
            request.SetRequestHeader(header.Key, header.Value);
        }
        await request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.ConnectionError || request.result == UnityWebRequest.Result.ProtocolError)
        {
            Debug.LogError(request.error);
            throw new Exception();
        }
        else
        {
            var responseString = request.downloadHandler.text;
            var responseObject = JsonUtility.FromJson<TextCompletionResponseModel>(responseString);
            return responseObject;
        }
    }
}

namespace AAA.OpenAI
{
    [System.Serializable]
    public class TextCompletionResponseModel
    {
        public string id;
        public long created;
        public string model;
        public List<Choice> choices;
        public Usage usage;

        [System.Serializable]
        public class Choice
        {
            public string text;
            public int index;
            public string finish_reason;
        }

        [System.Serializable]
        public class Usage
        {
            public int prompt_tokens;
            public int completion_tokens;
            public int total_tokens;
        }
    }
}

var aiResponseResult = await _openAIConnection.RequestCompletionAsync(micInputText);
var aiResponseText = aiResponseResult.choices[0].text;

public class VoiceVoxConnection
{
    private readonly string _voiceVoxUrl = "http://127.0.0.1:50021";
    private readonly int _speaker = 3;

    public VoiceVoxConnection(int speaker)
    {
        _speaker = speaker;
    }

    public async UniTask<AudioClip> TranslateTextToAudioClip(string text)
    {
        var queryJson = await SendAudioQuery(text);
        var clip = await GetAudioClip(queryJson);
        return clip;
    }

    private async UniTask<string> SendAudioQuery(string text)
    {
        var form = new WWWForm();
        using var request = UnityWebRequest.Post($"{_voiceVoxUrl}/audio_query?text={text}&speaker={_speaker}", form);
        await request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.ConnectionError ||
            request.result == UnityWebRequest.Result.ProtocolError)
        {
            Debug.LogError(request.error);
        }
        else
        {
            var jsonString = request.downloadHandler.text;
            return jsonString;
        }

        return null;
    }

    private async UniTask<AudioClip> GetAudioClip(string queryJson)
    {
        var url = $"{_voiceVoxUrl}/synthesis?speaker={_speaker}";
        using var req = new UnityWebRequest(url, "POST");
        // Content-Type を設定
        req.SetRequestHeader("Content-Type", "application/json");

        // リクエストボディを設定
        byte[] bodyRaw = System.Text.Encoding.UTF8.GetBytes(queryJson);
        req.uploadHandler = new UploadHandlerRaw(bodyRaw);
        // レスポンスの取得に必要な設定を行う
        req.downloadHandler = new DownloadHandlerBuffer();

        await req.SendWebRequest();

        if (req.result == UnityWebRequest.Result.ConnectionError ||
            req.result == UnityWebRequest.Result.ProtocolError)
        {
            Debug.LogError(req.error);
        }
        else
        {
            var audioClip = WavUtility.ToAudioClip(req.downloadHandler.data);
            return audioClip;
        }

        return null;
    }
}

public static AudioClip ToAudioClip(byte[] data)
{
    // ヘッダー解析
    int channels = data[22];
    int frequency = BitConverter.ToInt32(data, 24);
    int length = data.Length - 44;
    float[] samples = new float[length / 2];

    // 波形データ解析
    for (int i = 0; i < length / 2; i++)
    {
        short value = BitConverter.ToInt16(data, i * 2 + 44);
        samples[i] = value / 32768f;
    }

    // AudioClipを作成
    AudioClip audioClip = AudioClip.Create("AudioClip", samples.Length, channels, frequency, false);
    audioClip.SetData(samples, 0);

    return audioClip;
}

var clip = await _voiceVoxConnection.TranslateTextToAudioClip(aiResponseText);

audioSource.clip = clip;
audioSource.Play();