'the errors from my uvicorn server after inferencing with my runtime version of my unity script that communicates with it'
025-07-02 23:42:54.590 | INFO     | acestep.pipeline_ace_step:save_wav_file:1443 - Saving audio to C:\AI\ACE-Step\output_c735f18a3ee44effb2079d5969c629e2.wav
100%|████████████████████████████████████████████████████████████████████████████████████| 1/1 [00:00<00:00, 68.51it/s]
INFO:     127.0.0.1:60578 - "POST /generate HTTP/1.1" 200 OK
INFO:     127.0.0.1:60578 - "GET /output_c735f18a3ee44effb2079d5969c629e2.wav HTTP/1.1" 404 Not Found <======== ERROR! >~<

'my unity script c# class'
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.IO;
using UnityEngine;
using UnityEngine.Networking;

[Serializable]
public class ACEStepInput
{
    public string checkpoint_path;
    public bool bf16 = true;
    public bool torch_compile = false;
    public int device_id = 0;
    public string output_path; // ignored by server with above code
    public float audio_duration;
    public string prompt;
    public string lyrics;
    public int infer_step;
    public float guidance_scale;
    public string scheduler_type;
    public string cfg_type;
    public float omega_scale;
    public List<int> actual_seeds;
    public float guidance_interval;
    public float guidance_interval_decay;
    public float min_guidance_scale;
    public bool use_erg_tag;
    public bool use_erg_lyric;
    public bool use_erg_diffusion;
    public List<int> oss_steps;
    public float guidance_scale_text = 0.0f;
    public float guidance_scale_lyric = 0.0f;
}

[Serializable]
public class ACEStepOutput
{
    public string status;
    public string output_path;  // filename returned by server
    public string message;
}

public class ACEStepClient : MonoBehaviour
{
    // Server base URL (no trailing slash)
    public string serverBaseUrl = "http://localhost:8000";

    /// <summary>
    /// Start generation request.
    /// </summary>
    public void GenerateAudio(ACEStepInput input, Action<ACEStepOutput> onSuccess, Action<string> onError)
    {
        StartCoroutine(GenerateAudioRoutine(input, onSuccess, onError));
    }

    public IEnumerator GenerateAudioRoutine(ACEStepInput input, Action<ACEStepOutput> onSuccess, Action<string> onError)
    {
        string url = serverBaseUrl + "/generate";
        string jsonData = JsonUtility.ToJson(input);
        byte[] bodyRaw = Encoding.UTF8.GetBytes(jsonData);

        using (UnityWebRequest request = new UnityWebRequest(url, "POST"))
        {
            request.uploadHandler = new UploadHandlerRaw(bodyRaw);
            request.downloadHandler = new DownloadHandlerBuffer();
            request.SetRequestHeader("Content-Type", "application/json");

            yield return request.SendWebRequest();

#if UNITY_2020_1_OR_NEWER
            bool isError = request.result == UnityWebRequest.Result.ConnectionError || request.result == UnityWebRequest.Result.ProtocolError;
#else
            bool isError = request.isNetworkError || request.isHttpError;
#endif

            if (isError)
            {
                Debug.LogError($"Error sending request: {request.error}");
                onError?.Invoke(request.error);
            }
            else
            {
                try
                {
                    ACEStepOutput output = JsonUtility.FromJson<ACEStepOutput>(request.downloadHandler.text);
                    if (output.status == "success")
                    {
                        onSuccess?.Invoke(output);
                    }
                    else
                    {
                        onError?.Invoke($"Server returned error: {output.message}");
                    }
                }
                catch (Exception e)
                {
                    Debug.LogError($"Error parsing response: {e.Message}");
                    onError?.Invoke($"Error parsing response: {e.Message}");
                }
            }
        }
    }

    /// <summary>
    /// Downloads audio file by filename returned from server
    /// and saves it inside the selected Unity output folder.
    /// </summary>
    public IEnumerator DownloadAndSaveAudio(string filename, string unityOutputFolder, Action<string> onComplete, Action<string> onError)
    {
        if (string.IsNullOrEmpty(filename))
        {
            onError?.Invoke("Empty filename specified");
            yield break;
        }

        string downloadUrl = $"{serverBaseUrl}/{filename}";

        using (UnityWebRequest www = UnityWebRequest.Get(downloadUrl))
        {
            yield return www.SendWebRequest();

#if UNITY_2020_1_OR_NEWER
            bool isError = www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError;
#else
            bool isError = www.isNetworkError || www.isHttpError;
#endif

            if (isError)
            {
                Debug.LogError($"Error downloading audio file: {www.error}");
                onError?.Invoke(www.error);
                yield break;
            }

            byte[] audioData = www.downloadHandler.data;

            // Check if directory exists, else create it
            if (!Directory.Exists(unityOutputFolder))
            {
                Directory.CreateDirectory(unityOutputFolder);
            }

            string localPath = Path.Combine(unityOutputFolder, filename);

            try
            {
                File.WriteAllBytes(localPath, audioData);
                Debug.Log($"Audio file saved to {localPath}");
                onComplete?.Invoke(localPath);
            }
            catch (Exception e)
            {
                Debug.LogError($"Failed to save audio file: {e.Message}");
                onError?.Invoke(e.Message);
            }
        }
    }
}

'my unity script runtime example script'
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UnityEngine.Networking;

public class ACEStepRuntimeInference : MonoBehaviour
{
    [Header("Server Settings")]
    [Tooltip("Base URL of the inference server (no trailing slash)")]
    public string serverBaseUrl = "http://localhost:8000";

    [Header("Input Parameters")]

    public string checkpoint_path = "";

    public bool bf16 = true;
    public bool torch_compile = false;
    public int device_id = 0;

    [Tooltip("Ignored by server")]
    public string output_path = ""; // We will not use, but kept for completeness

    public float audio_duration = 10f;

    [TextArea(2, 5)]
    public string prompt = "";

    [TextArea(2, 5)]
    public string lyrics = "";

    public int infer_step = 50;

    public float guidance_scale = 7.5f;

    public string scheduler_type = "euler";

    public string cfg_type = "apg";

    public float omega_scale = 1.0f;

    [Tooltip("Seeds for random generator")]
    public List<int> actual_seeds = new List<int> { };

    public float guidance_interval = 1.0f;

    public float guidance_interval_decay = 0.0f;

    public float min_guidance_scale = 0.0f;

    public bool use_erg_tag = false;
    public bool use_erg_lyric = false;
    public bool use_erg_diffusion = false;

    [Tooltip("OSS steps")]
    public List<int> oss_steps = new List<int> { };

    public float guidance_scale_text = 0.0f;
    public float guidance_scale_lyric = 0.0f;

    [Header("Output")]
    [Tooltip("Local folder to save downloaded audio")]
    public string localSaveFolder;

    [Header("Generation Result")]
    [Tooltip("AudioClip loaded from the generated audio file")]
    public AudioClip GenerationResult;

    [Header("Generation State")]
    [Tooltip("True when generation is in progress")]
    public bool IsGenerating = false;  // <-- Added public bool to track generating status

    private ACEStepClient client;

    void Awake()
    {
        if (string.IsNullOrEmpty(localSaveFolder))
        {
            localSaveFolder = Path.Combine(Application.persistentDataPath, "GeneratedAudio");
        }

        client = GetComponent<ACEStepClient>();
        if (client == null)
        {
            client = gameObject.AddComponent<ACEStepClient>();
        }
        client.serverBaseUrl = serverBaseUrl;
    }

    [ContextMenu("Start Generate Audio")]
    public void StartGenerate()
    {
        if (IsGenerating)
        {
            Debug.LogWarning("Generation is already in progress.");
            return; // Avoid starting again if already generating
        }

        IsGenerating = true;
        ACEStepInput input = BuildACEStepInput();

        client.GenerateAudio(input, OnGenerateSuccess, OnGenerateError);
    }

    private ACEStepInput BuildACEStepInput()
    {
        return new ACEStepInput()
        {
            checkpoint_path = checkpoint_path,
            bf16 = bf16,
            torch_compile = torch_compile,
            device_id = device_id,
            output_path = output_path,
            audio_duration = audio_duration,
            prompt = prompt,
            lyrics = lyrics,
            infer_step = infer_step,
            guidance_scale = guidance_scale,
            scheduler_type = scheduler_type,
            cfg_type = cfg_type,
            omega_scale = omega_scale,
            actual_seeds = new List<int>(actual_seeds),
            guidance_interval = guidance_interval,
            guidance_interval_decay = guidance_interval_decay,
            min_guidance_scale = min_guidance_scale,
            use_erg_tag = use_erg_tag,
            use_erg_lyric = use_erg_lyric,
            use_erg_diffusion = use_erg_diffusion,
            oss_steps = new List<int>(oss_steps),
            guidance_scale_text = guidance_scale_text,
            guidance_scale_lyric = guidance_scale_lyric,
        };
    }

    private void OnGenerateSuccess(ACEStepOutput output)
    {
        Debug.Log("Generation success! Output path: " + output.output_path);

        if (string.IsNullOrEmpty(output.output_path))
        {
            Debug.LogWarning("Output path from server is empty");
            SetFilePathText("No output file returned from server");
            IsGenerating = false;
            return;
        }

        StartCoroutine(client.DownloadAndSaveAudio(output.output_path, localSaveFolder, OnDownloadComplete, OnDownloadError));
    }

    private void OnGenerateError(string error)
    {
        Debug.LogError("Generation failed: " + error);
        SetFilePathText("Generation failed: " + error);
        IsGenerating = false;
    }

    private void OnDownloadComplete(string localFullPath)
    {
        Debug.Log("Download and save completed: " + localFullPath);
        SetFilePathText(localFullPath);
        IsGenerating = false;
    }

    private void OnDownloadError(string error)
    {
        Debug.LogError("Download failed: " + error);
        SetFilePathText("Download failed: " + error);
        IsGenerating = false;
    }

    private void SetFilePathText(string text)
    {
        // If the path is a valid existing file, try to load it as an AudioClip
        if (!string.IsNullOrEmpty(text) && File.Exists(text))
        {
            StartCoroutine(LoadAudioClipFromFile(text));
        }
        else
        {
            // Clear the audio clip if path invalid or error message
            GenerationResult = null;
        }
    }

    private IEnumerator LoadAudioClipFromFile(string filePath)
    {
        if (!File.Exists(filePath))
        {
            Debug.LogError($"Audio file not found on disk: {filePath}");
            GenerationResult = null;
            yield break;
        }

        string uri = "file://" + filePath;

        AudioType audioType = GetAudioTypeFromFileExtension(filePath);

        using (UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(uri, audioType))
        {
            yield return www.SendWebRequest();

#if UNITY_2020_1_OR_NEWER
            bool isError = www.result == UnityWebRequest.Result.ConnectionError || www.result == UnityWebRequest.Result.ProtocolError;
#else
            bool isError = www.isNetworkError || www.isHttpError;
#endif
            if (isError)
            {
                Debug.LogError($"Failed to load audio clip from file: {www.error}");
                GenerationResult = null;
            }
            else
            {
                AudioClip clip = DownloadHandlerAudioClip.GetContent(www);
                if (clip == null)
                {
                    Debug.LogError("Loaded AudioClip is null");
                    GenerationResult = null;
                }
                else
                {
                    Debug.Log($"AudioClip loaded successfully from {filePath}");
                    GenerationResult = clip;
                }
            }
        }
    }

    private AudioType GetAudioTypeFromFileExtension(string filePath)
    {
        string extension = Path.GetExtension(filePath).ToLowerInvariant();
        switch (extension)
        {
            case ".wav": return AudioType.WAV;
            case ".mp3": return AudioType.MPEG;
            case ".ogg": return AudioType.OGGVORBIS;
            case ".aiff": return AudioType.AIFF;
            case ".mod": return AudioType.MOD;
            case ".xm": return AudioType.XM;
            case ".it": return AudioType.IT;
            case ".s3m": return AudioType.S3M;
            default:
                Debug.LogWarning($"Unknown audio file extension '{extension}', defaulting to WAV");
                return AudioType.WAV;
        }
    }
}

'further task notes'
please fix both and provide both full and fixed tysm.