feat(asset-gen): add MiniMax music cover support

Author: octo-patch

MCPForUnity/Editor/Services/AssetGen/AssetGenJobManager.cs

@@ -443,7 +443,7 @@ private static void Advance(Runner r)
         // RCE. Anything outside these sets is rejected. Mirrors ModelImportPipeline's allowlist style.
         private static readonly HashSet<string> AudioAllowedExtensions = new(StringComparer.OrdinalIgnoreCase)
         {
-            "wav", "mp3", "ogg", "aiff", "aif", "flac",
+            "wav", "mp3", "pcm", "ogg", "aiff", "aif", "flac",
         };
         private static readonly HashSet<string> ImageAllowedExtensions = new(StringComparer.OrdinalIgnoreCase)
         {

MCPForUnity/Editor/Services/AssetGen/AssetGenModelCatalog.cs

@@ -68,6 +68,10 @@ public static class AssetGenModelCatalog
             new ModelEntry { Id = "cassetteai/music-generator", Label = "CassetteAI Music", Provider = "fal", Kind = "audio", UseCase = "Background music", PriceLabel = "$0.02/min", MaxDurationSeconds = 180f,
                 DurationField = "duration", DefaultDurationSeconds = 10f, MinDurationSeconds = 1f },
             new ModelEntry { Id = "fal-ai/lyria2", Label = "Google Lyria 2", Provider = "fal", Kind = "audio", UseCase = "Background music", PriceLabel = "$0.10/30s", MaxDurationSeconds = 30f },
+
+            // Audio cover — MiniMax. Reference input must be 6-360 seconds and no larger than 50 MB.
+            new ModelEntry { Id = MiniMaxAudioAdapter.DefaultModel, Label = "MiniMax Music Cover", Provider = "minimax", Kind = "audio", UseCase = "Reference-audio cover" },
+            new ModelEntry { Id = "music-cover-free", Label = "MiniMax Music Cover (free)", Provider = "minimax", Kind = "audio", UseCase = "Reference-audio cover" },
         };
 
         /// <summary>Curated entries for a provider+kind, in curated order (default first). Never null.</summary>

MCPForUnity/Editor/Services/AssetGen/Providers/AssetGenProviders.cs

@@ -44,6 +44,8 @@ public static IAudioProviderAdapter Audio(string id)
             {
                 case "fal":
                     return new FalAudioAdapter();
+                case "minimax":
+                    return new MiniMaxAudioAdapter();
                 default:
                     throw new NotSupportedException($"Unknown audio provider '{id}'.");
             }
@@ -71,6 +73,7 @@ public static IReadOnlyList<ProviderInfo> List()
                 new ProviderInfo { Id = "openrouter", Kind = "image", Configured = IsConfigured("openrouter"), Capabilities = new[] { "text", "image" } },
                 // fal appears twice by design — once per kind (image + audio) — sharing the single "fal" key.
                 new ProviderInfo { Id = "fal", Kind = "audio", Configured = IsConfigured("fal"), Capabilities = new[] { "text", "music", "sfx" } },
+                new ProviderInfo { Id = "minimax", Kind = "audio", Configured = IsConfigured("minimax"), Capabilities = new[] { "music", "cover", "url", "base64" } },
             };
         }
 

MCPForUnity/Editor/Services/AssetGen/Providers/MiniMaxAudioAdapter.cs

@@ -0,0 +1,247 @@
+using System;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using MCPForUnity.Editor.Security;
+using MCPForUnity.Editor.Services.AssetGen.Http;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace MCPForUnity.Editor.Services.AssetGen.Providers
+{
+    /// <summary>
+    /// MiniMax music-cover adapter for the synchronous music-generation endpoint. A cover accepts
+    /// one raw reference source (URL or base64 audio) and an optional preprocessed feature id, then
+    /// exposes the returned URL or hex payload through the normal audio job pipeline.
+    /// </summary>
+    public sealed class MiniMaxAudioAdapter : IAudioProviderAdapter
+    {
+        internal const string GlobalEndpoint = "https://api.minimax.io/v1/music_generation";
+        internal const string ChinaEndpoint = "https://api.minimaxi.com/v1/music_generation";
+        internal const string RegionEnvVar = "MCPFORUNITY_MINIMAX_REGION";
+        internal const string DefaultModel = "music-cover";
+
+        private const string GlobalHost = "api.minimax.io";
+        private const string ChinaHost = "api.minimaxi.com";
+        private const string FreeModel = "music-cover-free";
+
+        private byte[] _inlineData;
+        private string _downloadUrl;
+        private string _resultExt;
+        private string _error;
+
+        public string Id => "minimax";
+
+        internal static bool IsCoverModel(string model)
+            => string.Equals(model, DefaultModel, StringComparison.Ordinal)
+               || string.Equals(model, FreeModel, StringComparison.Ordinal);
+
+        public async Task<string> SubmitAsync(
+            AudioGenRequest req,
+            string apiKey,
+            IHttpTransport http,
+            CancellationToken ct)
+        {
+            if (req == null) throw new ArgumentNullException(nameof(req));
+            if (http == null) throw new ArgumentNullException(nameof(http));
+
+            string model = string.IsNullOrWhiteSpace(req.Model) ? DefaultModel : req.Model;
+            ValidateRequest(req, model);
+            ResolveRegion(out string endpoint, out string host, out bool chinaRegion);
+            ProviderHttp.RequireHost(endpoint, host, apiKey, "MiniMax cover submit");
+
+            var spec = new HttpRequestSpec
+            {
+                Method = "POST",
+                Url = endpoint,
+                ContentType = "application/json",
+                Body = Encoding.UTF8.GetBytes(BuildBody(req, model, chinaRegion).ToString(Formatting.None))
+            };
+            spec.Headers["Authorization"] = "Bearer " + apiKey;
+
+            HttpResult response = await http.SendAsync(spec, ct);
+            JObject json = ParseOk(response, apiKey);
+
+            int statusCode = AsInt(json["base_resp"]?["status_code"], -1);
+            if (statusCode != 0)
+            {
+                string statusMessage = json["base_resp"]?["status_msg"]?.ToString();
+                _error = SecretRedactor.Scrub(
+                    $"MiniMax music cover failed (status_code={statusCode}): {statusMessage ?? "unknown error"}",
+                    apiKey);
+                return "ready";
+            }
+
+            JToken data = json["data"];
+            int generationStatus = AsInt(data?["status"], -1);
+            if (generationStatus != 2)
+            {
+                _error = generationStatus == 1
+                    ? "MiniMax music cover is still in progress, but the response included no query endpoint."
+                    : $"MiniMax music cover returned an unexpected status ({generationStatus}).";
+                return "ready";
+            }
+
+            string audio = data?["audio"]?.ToString();
+            if (string.IsNullOrWhiteSpace(audio))
+            {
+                _error = "MiniMax music cover completed without audio data.";
+                return "ready";
+            }
+
+            if (Uri.TryCreate(audio, UriKind.Absolute, out Uri audioUri)
+                && (audioUri.Scheme == Uri.UriSchemeHttp || audioUri.Scheme == Uri.UriSchemeHttps))
+            {
+                _downloadUrl = audio;
+            }
+            else
+            {
+                _inlineData = TryDecodeHex(audio);
+                if (_inlineData == null || _inlineData.Length == 0)
+                {
+                    _error = "MiniMax returned an unrecognized audio payload.";
+                    return "ready";
+                }
+            }
+
+            _resultExt = NormalizeAudioFormat(req.AudioFormat);
+            return "ready";
+        }
+
+        public Task<ProviderPollResult> PollAsync(
+            string providerJobId,
+            string apiKey,
+            IHttpTransport http,
+            CancellationToken ct)
+        {
+            var result = new ProviderPollResult { Progress = 1f };
+            if (!string.IsNullOrEmpty(_error) || (_inlineData == null && string.IsNullOrEmpty(_downloadUrl)))
+            {
+                result.State = ProviderPollState.Failed;
+                result.Error = _error ?? "MiniMax produced no cover audio.";
+            }
+            else
+            {
+                result.State = ProviderPollState.Succeeded;
+                result.InlineData = _inlineData;
+                result.DownloadUrl = _downloadUrl;
+                result.ResultExt = _resultExt;
+            }
+            return Task.FromResult(result);
+        }
+
+        private static void ValidateRequest(AudioGenRequest req, string model)
+        {
+            if (!IsCoverModel(model))
+                throw new NotSupportedException("MiniMax audio supports music-cover and music-cover-free.");
+
+            int sourceCount = 0;
+            if (!string.IsNullOrWhiteSpace(req.AudioUrl)) sourceCount++;
+            if (!string.IsNullOrWhiteSpace(req.AudioBase64)) sourceCount++;
+            if (sourceCount != 1)
+                throw new ArgumentException("Provide exactly one cover source: audio_url or audio_base64.");
+
+            NormalizeOutputFormat(req.OutputFormat);
+            NormalizeAudioFormat(req.AudioFormat);
+        }
+
+        private static JObject BuildBody(AudioGenRequest req, string model, bool chinaRegion)
+        {
+            var body = new JObject
+            {
+                ["model"] = model,
+                ["stream"] = false,
+                ["output_format"] = NormalizeOutputFormat(req.OutputFormat),
+                ["audio_setting"] = new JObject
+                {
+                    ["format"] = NormalizeAudioFormat(req.AudioFormat)
+                }
+            };
+
+            if (!string.IsNullOrWhiteSpace(req.Prompt)) body["prompt"] = req.Prompt;
+            if (!string.IsNullOrWhiteSpace(req.Lyrics)) body["lyrics"] = req.Lyrics;
+            if (req.LyricsOptimizer.HasValue) body["lyrics_optimizer"] = req.LyricsOptimizer.Value;
+            if (req.IsInstrumental.HasValue) body["is_instrumental"] = req.IsInstrumental.Value;
+            if (!string.IsNullOrWhiteSpace(req.AudioUrl)) body["audio_url"] = req.AudioUrl;
+            if (!string.IsNullOrWhiteSpace(req.AudioBase64)) body["audio_base64"] = req.AudioBase64;
+            if (!string.IsNullOrWhiteSpace(req.CoverFeatureId)) body["cover_feature_id"] = req.CoverFeatureId;
+            if (chinaRegion && req.AigcWatermark.HasValue) body["aigc_watermark"] = req.AigcWatermark.Value;
+            return body;
+        }
+
+        private static string NormalizeOutputFormat(string value)
+        {
+            string normalized = string.IsNullOrWhiteSpace(value) ? "url" : value.Trim().ToLowerInvariant();
+            if (normalized != "url" && normalized != "hex")
+                throw new ArgumentException("output_format must be 'url' or 'hex'.");
+            return normalized;
+        }
+
+        private static string NormalizeAudioFormat(string value)
+        {
+            string normalized = string.IsNullOrWhiteSpace(value) ? "mp3" : value.Trim().ToLowerInvariant();
+            if (normalized != "mp3" && normalized != "wav" && normalized != "pcm")
+                throw new ArgumentException("audio_format must be 'mp3', 'wav', or 'pcm'.");
+            return normalized;
+        }
+
+        private static void ResolveRegion(out string endpoint, out string host, out bool chinaRegion)
+        {
+            string region = (Environment.GetEnvironmentVariable(RegionEnvVar) ?? string.Empty)
+                .Trim().ToLowerInvariant();
+            chinaRegion = region == "cn" || region == "cn_zh" || region == "china";
+            endpoint = chinaRegion ? ChinaEndpoint : GlobalEndpoint;
+            host = chinaRegion ? ChinaHost : GlobalHost;
+        }
+
+        private static int AsInt(JToken token, int fallback)
+        {
+            if (token == null || token.Type == JTokenType.Null) return fallback;
+            if (token.Type == JTokenType.Integer) return (int)token;
+            return int.TryParse(token.ToString(), out int parsed) ? parsed : fallback;
+        }
+
+        private static byte[] TryDecodeHex(string hex)
+        {
+            if (string.IsNullOrEmpty(hex) || (hex.Length % 2) != 0) return null;
+            var bytes = new byte[hex.Length / 2];
+            for (int i = 0; i < bytes.Length; i++)
+            {
+                int high = HexValue(hex[i * 2]);
+                int low = HexValue(hex[i * 2 + 1]);
+                if (high < 0 || low < 0) return null;
+                bytes[i] = (byte)((high << 4) | low);
+            }
+            return bytes;
+        }
+
+        private static int HexValue(char value)
+        {
+            if (value >= '0' && value <= '9') return value - '0';
+            if (value >= 'a' && value <= 'f') return value - 'a' + 10;
+            if (value >= 'A' && value <= 'F') return value - 'A' + 10;
+            return -1;
+        }
+
+        private static JObject ParseOk(HttpResult response, string apiKey)
+        {
+            string text = ProviderHttp.BodyText(response);
+            JObject json = null;
+            if (!string.IsNullOrEmpty(text))
+            {
+                try { json = JObject.Parse(text); }
+                catch { /* handled below */ }
+            }
+
+            if (response?.Ok != true)
+            {
+                string detail = json?["base_resp"]?["status_msg"]?.ToString()
+                                ?? json?["error"]?.ToString()
+                                ?? ProviderHttp.Truncate(text);
+                throw new Exception(SecretRedactor.Scrub(
+                    $"MiniMax cover request failed (status={response?.Status}): {detail}", apiKey));
+            }
+            return json ?? new JObject();
+        }
+    }
+}

MCPForUnity/Editor/Services/AssetGen/Providers/MiniMaxAudioAdapter.cs.meta

@@ -63,16 +63,25 @@ public sealed class ImageGenRequest
     }
 
     /// <summary>
-    /// Request to generate an audio clip (fal.ai for v1). <see cref="Model"/> selects the fal
-    /// endpoint (stable-audio-25 / cassetteai/* / lyria2). <see cref="Duration"/> is a per-gen
-    /// input; 0 => provider default. Never carries a key; never persisted (transient request only).
+    /// Request to generate an audio clip. Cover-capable providers can consume reference audio as
+    /// a URL or base64 payload plus optional cover metadata. Never carries a key and is never
+    /// persisted (transient request only).
     /// </summary>
     public sealed class AudioGenRequest
     {
-        public string Provider; // "fal" for v1
-        public string Model; // fal model id, e.g. fal-ai/stable-audio-25/text-to-audio
+        public string Provider;
+        public string Model;
         public string Prompt;
         public float Duration; // seconds; 0 => per-model default. Soft-clamped per model in the adapter.
+        public string Lyrics;
+        public bool? LyricsOptimizer;
+        public bool? IsInstrumental;
+        public string AudioUrl;
+        public string AudioBase64;
+        public string CoverFeatureId;
+        public string OutputFormat;
+        public string AudioFormat;
+        public bool? AigcWatermark;
         public string Name;
         public string OutputFolder;
     }

MCPForUnity/Editor/Services/AssetGen/Providers/ProviderModels.cs

@@ -8,8 +8,8 @@
 namespace MCPForUnity.Editor.Tools.AssetGen
 {
     /// <summary>
-    /// Audio generation (SFX / music) via fal.ai. Triggered here (never from the GUI); the C# side
-    /// reads the fal key from the secure store and runs the job. Returns a job_id immediately; the
+    /// Audio generation and cover creation. Triggered here (never from the GUI); the C# side reads
+    /// the provider key from the secure store and runs the job. Returns a job_id immediately; the
     /// client polls the `status` action. When `model` is omitted it falls back to the model selected
     /// in the Asset Generation tab, then the catalog default. Status / cancel / list_providers are
     /// shared across the generate_* tools via <see cref="AssetGenToolHelpers"/>.
@@ -53,21 +53,43 @@ private static object Generate(ToolParams p)
             if (!SecureKeyStore.Current.Has(provider))
                 return new ErrorResponse(AssetGenProviders.MissingKeyMessage(provider));
 
-            string prompt = p.Get("prompt");
-            if (string.IsNullOrWhiteSpace(prompt))
-                return new ErrorResponse("'prompt' is required for audio generation.");
-
             // Empty -> GUI-selected model -> catalog default. A null model reaches the adapter's own
             // default; a resolved id is passed through verbatim (the catalog default equals the
             // adapter constant, so an omitted model is a no-op either way).
             string model = AssetGenModelCatalog.ResolveModel("audio", provider, p.Get("model"));
 
+            string prompt = p.Get("prompt");
+            if (string.Equals(provider, "minimax", StringComparison.OrdinalIgnoreCase))
+            {
+                if (!MiniMaxAudioAdapter.IsCoverModel(model))
+                    return new ErrorResponse("The MiniMax audio provider supports music-cover and music-cover-free.");
+
+                int sourceCount = 0;
+                if (!string.IsNullOrWhiteSpace(p.Get("audioUrl"))) sourceCount++;
+                if (!string.IsNullOrWhiteSpace(p.Get("audioBase64"))) sourceCount++;
+                if (sourceCount != 1)
+                    return new ErrorResponse("Provide exactly one of 'audioUrl' or 'audioBase64'.");
+            }
+            else if (string.IsNullOrWhiteSpace(prompt))
+            {
+                return new ErrorResponse("'prompt' is required for audio generation.");
+            }
+
             var req = new AudioGenRequest
             {
                 Provider = provider,
                 Model = model,
                 Prompt = prompt,
                 Duration = p.GetFloat("duration", 0f) ?? 0f,
+                Lyrics = p.Get("lyrics"),
+                LyricsOptimizer = p.Has("lyricsOptimizer") ? p.GetBool("lyricsOptimizer") : null,
+                IsInstrumental = p.Has("isInstrumental") ? p.GetBool("isInstrumental") : null,
+                AudioUrl = p.Get("audioUrl"),
+                AudioBase64 = p.Get("audioBase64"),
+                CoverFeatureId = p.Get("coverFeatureId"),
+                OutputFormat = p.Get("outputFormat"),
+                AudioFormat = p.Get("audioFormat"),
+                AigcWatermark = p.Has("aigcWatermark") ? p.GetBool("aigcWatermark") : null,
                 Name = p.Get("name"),
                 OutputFolder = p.Get("outputFolder"),
             };

MCPForUnity/Editor/Tools/AssetGen/GenerateAudio.cs

@@ -181,8 +181,9 @@ private void BuildProviderRows()
                 AddProviderRow(imagePanel, provider.Id, provider.Label, "image");
             }
 
-            var audioPanel = AddCategoryPanel("Sound (fal.ai)");
+            var audioPanel = AddCategoryPanel("Sound");
             AddAudioRow(audioPanel);
+            AddProviderRow(audioPanel, "minimax", "MiniMax", "audio");
 
             AddBlenderHandoffRow();
         }