ai.muna.muna 0.0.45 → 0.0.47

package/Editor/Build/AndroidBuildHandler.cs

@@ -15,12 +15,12 @@ namespace Muna.Editor.Build {
     using UnityEditor.Android;
     using UnityEditor.Build.Reporting;
     using API;
+    using Internal;
     using Services;
-    using MunaSettings = Internal.MunaSettings;
 
     internal sealed class AndroidBuildHandler : BuildHandler, IPostGenerateGradleAndroidProject {
 
-        private static List<CachedPrediction> cache;
+        private static List<PredictionCache.CachedPrediction> cache;
         private static Dictionary<AndroidArchitecture, string> ArchToClientId = new() {
             [AndroidArchitecture.ARMv7]     = @"android-armeabi-v7a",
             [AndroidArchitecture.ARM64]     = @"android-arm64-v8a",
@@ -49,7 +49,7 @@ namespace Muna.Editor.Build {
                                 clientId: target,
                                 configurationId: @""
                             )).Result;
-                            return new CachedPrediction(prediction, target);
+                            return prediction.AsCached(target);
                         } catch (AggregateException ex) {
                             Debug.LogWarning($"Muna: Failed to embed {tag} predictor with error: {ex.InnerException}. Predictions with this predictor will likely fail at runtime.");
                             return null;

package/Editor/Build/iOSBuildHandler.cs

@@ -16,7 +16,7 @@ namespace Muna.Editor.Build {
     using UnityEditor.Build;
     using UnityEditor.Build.Reporting;
     using API;
-    using MunaSettings = Internal.MunaSettings;
+    using Internal;
 
 #if UNITY_IOS || UNITY_VISIONOS
     using UnityEditor.iOS.Xcode;
@@ -25,7 +25,7 @@ namespace Muna.Editor.Build {
 
     internal sealed class iOSBuildHandler : BuildHandler, IPostprocessBuildWithReport {
 
-        private List<CachedPrediction> cache;
+        private List<PredictionCache.CachedPrediction> cache;
         private static readonly Dictionary<BuildTarget, string> ClientIds = new () {
             [BuildTarget.iOS] = @"ios-arm64",
             [BuildTarget.VisionOS] = @"visionos-arm64"
@@ -37,7 +37,7 @@ namespace Muna.Editor.Build {
             var projectSettings = MunaProjectSettings.instance;
             var settings = MunaSettings.Create(projectSettings.accessKey);
             var embeds = GetEmbeds();
-            var cache = new List<CachedPrediction>();
+            var cache = new List<PredictionCache.CachedPrediction>();
             var clientId = ClientIds[report.summary.platform];
             foreach (var embed in embeds) {
                 var client = new DotNetClient(embed.url, embed.accessKey);
@@ -50,7 +50,7 @@ namespace Muna.Editor.Build {
                                 clientId: clientId,
                                 configurationId: @""
                             )).Result;
-                            return new CachedPrediction(prediction, clientId);
+                            return prediction.AsCached(clientId);
                         } catch (AggregateException ex) {
                             Debug.LogWarning($"Muna: Failed to embed {tag} predictor with error: {ex.InnerException}. Predictions with this predictor will likely fail at runtime.");
                             return null;

package/Editor/Build/macOSBuildHandler.cs

@@ -15,17 +15,17 @@ namespace Muna.Editor.Build {
     using UnityEditor.Build;
     using UnityEditor.Build.Reporting;
     using API;
+    using Internal;
     using Services;
-    using MunaSettings = Internal.MunaSettings;
 
-    #if UNITY_STANDALONE_OSX
+#if UNITY_STANDALONE_OSX
     using UnityEditor.iOS.Xcode;
     using UnityEditor.iOS.Xcode.Extensions;
-    #endif
+#endif
 
     internal sealed class macOSBuildHandler : BuildHandler, IPostprocessBuildWithReport {
 
-        private List<CachedPrediction> cache;
+        private List<PredictionCache.CachedPrediction> cache;
         private static readonly string[] ClientIds = new[] {
             "macos-arm64",
             "macos-x86_64"
@@ -41,7 +41,7 @@ namespace Muna.Editor.Build {
             var settings = MunaSettings.Create(projectSettings.accessKey);
             // Embed predictors
             var embeds = GetEmbeds();
-            var cache = new List<CachedPrediction>();
+            var cache = new List<PredictionCache.CachedPrediction>();
             foreach (var embed in embeds) {
                 var client = new DotNetClient(embed.url, embed.accessKey);
                 var muna = new Muna(client);
@@ -54,7 +54,7 @@ namespace Muna.Editor.Build {
                                 clientId: clientId,
                                 configurationId: @""
                             )).Result;
-                            return new CachedPrediction(prediction, clientId);
+                            return prediction.AsCached(clientId);
                         }
                         catch (AggregateException ex) {
                             Debug.LogWarning($"Muna: Failed to embed {tag} predictor with error: {ex.InnerException}. Predictions with this predictor will likely fail at runtime.");

package/Editor/MunaMenu.cs

@@ -7,35 +7,33 @@ namespace Muna.Editor {
 
     using System.IO;
     using UnityEditor;
+    using Internal;
 
     internal static class MunaMenu {
 
         private const int BasePriority = -50;
 
-        [MenuItem(@"Muna/Muna " + Muna.Version, false, BasePriority)]
+        [MenuItem(@"Tools/Muna/Muna " + Muna.Version, false, BasePriority)]
         private static void Version() { }
 
-        [MenuItem(@"Muna/Muna " + Muna.Version, true, BasePriority)]
+        [MenuItem(@"Tools/Muna/Muna " + Muna.Version, true, BasePriority)]
         private static bool EnableVersion() => false;
 
-        [MenuItem(@"Muna/Get Access Key", false, BasePriority + 1)]
+        [MenuItem(@"Tools/Muna/Get Access Key", false, BasePriority + 1)]
         private static void GetAccessKey() => Help.BrowseURL(@"https://muna.ai/settings/developer");
 
-        [MenuItem(@"Muna/Explore Predictors", false, BasePriority + 2)]
+        [MenuItem(@"Tools/Muna/Explore Predictors", false, BasePriority + 2)]
         private static void OpenExplore() => Help.BrowseURL(@"https://muna.ai/explore");
 
-        [MenuItem(@"Muna/View the Docs", false, BasePriority + 3)]
+        [MenuItem(@"Tools/Muna/View the Docs", false, BasePriority + 3)]
         private static void OpenDocs() => Help.BrowseURL(@"https://docs.muna.ai");
 
-        [MenuItem(@"Muna/Report an Issue", false, BasePriority + 4)]
+        [MenuItem(@"Tools/Muna/Report an Issue", false, BasePriority + 4)]
         private static void ReportIssue() => Help.BrowseURL(@"https://github.com/muna-ai/muna-unity");
 
-        [MenuItem(@"Muna/Clear Predictor Cache", false, BasePriority + 5)]
+        [MenuItem(@"Tools/Muna/Clear Predictor Cache", false, BasePriority + 5)]
         private static void ClearPredictorCache() {
-            Directory.Delete(
-                global::Muna.API.PredictionCacheClient.PredictorCachePath,
-                true
-            );
+            Directory.Delete(PredictionCache.PredictorCachePath, true);
             UnityEngine.Debug.Log("Muna: Cleared predictor cache.");
         }
     }

package/Plugins/macOS/Function.dylib.meta

@@ -2,7 +2,7 @@ fileFormatVersion: 2
 guid: 62aec3fdf35a340f78ab3a076fc7ca3e
 PluginImporter:
   externalObjects: {}
-  serializedVersion: 3
+  serializedVersion: 2
   iconMap: {}
   executionOrder: {}
   defineConstraints: []
@@ -11,52 +11,53 @@ PluginImporter:
   isExplicitlyReferenced: 0
   validateReferences: 1
   platformData:
-    Android:
+  - first:
+      : 
+    second:
       enabled: 0
-      settings:
-        AndroidLibraryDependee: UnityLibrary
-        AndroidSharedLibraryType: Executable
-        CPU: ARMv7
-    Any:
+      settings: {}
+  - first:
+      : Any
+    second:
       enabled: 0
       settings:
-        Exclude Android: 1
         Exclude Editor: 0
         Exclude Linux64: 1
         Exclude OSXUniversal: 0
-        Exclude WebGL: 1
         Exclude Win: 1
         Exclude Win64: 1
-        Exclude iOS: 1
-    Editor:
+  - first:
+      Editor: Editor
+    second:
       enabled: 1
       settings:
         CPU: ARM64
         DefaultValueInitialized: true
         OS: OSX
-    Linux64:
+  - first:
+      Standalone: Linux64
+    second:
       enabled: 0
       settings:
-        CPU: AnyCPU
-    OSXUniversal:
+        CPU: x86_64
+  - first:
+      Standalone: OSXUniversal
+    second:
       enabled: 1
       settings:
         CPU: ARM64
-    Win:
-      enabled: 0
-      settings:
-        CPU: AnyCPU
-    Win64:
+  - first:
+      Standalone: Win
+    second:
       enabled: 0
       settings:
-        CPU: AnyCPU
-    iOS:
+        CPU: x86
+  - first:
+      Standalone: Win64
+    second:
       enabled: 0
       settings:
-        AddToEmbeddedBinaries: false
-        CPU: AnyCPU
-        CompileFlags: 
-        FrameworkDependencies: 
+        CPU: x86_64
   userData: 
   assetBundleName: 
   assetBundleVariant: 

package/README.md

@@ -16,7 +16,7 @@ Add the following items to your Unity project's `Packages/manifest.json`:
     }
   ],
   "dependencies": {
-    "ai.muna.muna": "0.0.45"
+    "ai.muna.muna": "0.0.47"
   }
 }
 ```

package/Runtime/Beta/OpenAI/SpeechService.cs

@@ -190,6 +190,12 @@ namespace Muna.Beta.OpenAI {
                 StreamFormat streamFormat,
                 object acceleration
             ) => {
+                // Check response format
+                if (responseFormat != ResponseFormat.PCM)
+                    throw new ArgumentException($"Cannot create speech with response format  {responseFormat} because only `ResponseFormat.PCM` is supported.");
+                // Check stream format
+                if (streamFormat != StreamFormat.Audio)
+                    throw new ArgumentException($"Cannot create speech with stream format  {streamFormat} because only `StreamFormat.Audio` is supported.");
                 // Build prediction input map
                 var inputMap = new Dictionary<string, object?> {
                     [inputParam.name] = input,

package/Runtime/Beta/OpenAI/Types.cs

@@ -35,7 +35,6 @@ namespace Muna.Beta.OpenAI {
         /// <summary>
         /// Convert the `BinaryData` to a byte array.
         /// </summary>
-        /// <returns></returns>
         public byte[] ToArray() => data;
 
         /// <summary>

package/Runtime/Beta/Remote/RemotePredictionService.cs

@@ -69,51 +69,52 @@ namespace Muna.Beta.Services {
 
         internal RemotePredictionService(MunaClient client) => this.client = client;
 
-        private async Task<Value> ToValue(object? value) => value switch { // INCOMPLETE // Image
-            null              => new Value { type = Dtype.Null },
-            float           x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Float32, shape = new int[0] },
-            double          x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Float64, shape = new int[0] },
-            sbyte           x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Int8, shape = new int[0] },
-            short           x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Int16, shape = new int[0] },
-            int             x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Int32, shape = new int[0] },
-            long            x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Int64, shape = new int[0] },
-            byte            x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Uint8, shape = new int[0] },
-            ushort          x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Uint16, shape = new int[0] },
-            uint            x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Uint32, shape = new int[0] },
-            ulong           x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Uint64, shape = new int[0] },
-            bool            x => new Value { data = await Upload(new [] { x }.ToStream()), type = Dtype.Bool, shape = new int[0] },
-            float[]         x => new Value { data = await Upload(x.ToStream()), type = Dtype.Float32, shape = new [] { x.Length } },
-            double[]        x => new Value { data = await Upload(x.ToStream()), type = Dtype.Float64, shape = new [] { x.Length } },
-            sbyte[]         x => new Value { data = await Upload(x.ToStream()), type = Dtype.Int8, shape = new [] { x.Length } },
-            short[]         x => new Value { data = await Upload(x.ToStream()), type = Dtype.Int16, shape = new [] { x.Length } },
-            int[]           x => new Value { data = await Upload(x.ToStream()), type = Dtype.Int32, shape = new [] { x.Length } },
-            long[]          x => new Value { data = await Upload(x.ToStream()), type = Dtype.Int64, shape = new [] { x.Length } },
-            byte[]          x => new Value { data = await Upload(x.ToStream()), type = Dtype.Uint8, shape = new [] { x.Length } },
-            ushort[]        x => new Value { data = await Upload(x.ToStream()), type = Dtype.Uint16, shape = new [] { x.Length } },
-            uint[]          x => new Value { data = await Upload(x.ToStream()), type = Dtype.Uint32, shape = new [] { x.Length } },
-            ulong[]         x => new Value { data = await Upload(x.ToStream()), type = Dtype.Uint64, shape = new [] { x.Length } },
-            bool[]          x => new Value { data = await Upload(x.ToStream()), type = Dtype.Bool, shape = new [] { x.Length } },
-            Tensor<float>   x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Float32, shape = x.shape },
-            Tensor<double>  x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Float64, shape = x.shape },
-            Tensor<sbyte>   x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Int8, shape = x.shape },
-            Tensor<short>   x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Int16, shape = x.shape },
-            Tensor<int>     x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Int32, shape = x.shape },
-            Tensor<long>    x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Int64, shape = x.shape },
-            Tensor<byte>    x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Uint8, shape = x.shape },
-            Tensor<ushort>  x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Uint16, shape = x.shape },
-            Tensor<uint>    x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Uint32, shape = x.shape },
-            Tensor<ulong>   x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Uint64, shape = x.shape },
-            Tensor<bool>    x => new Value { data = await Upload(x.data.ToStream()), type = Dtype.Bool, shape = x.shape },
-            string          x => new Value { data = await Upload(x.ToStream(), mime: @"text/plain"), type = Dtype.String },
-            IList           x => new Value { data = await Upload(JsonConvert.SerializeObject(x).ToStream(), mime: @"application/json"), type = Dtype.List },
-            IDictionary     x => new Value { data = await Upload(JsonConvert.SerializeObject(x).ToStream(), mime: @"application/json"), type = Dtype.Dict },
-            Image           x => new Value { data = "", type = Dtype.Image },
-            Stream          x => new Value { data = await Upload(x), type = Dtype.Binary },
+        private async Task<RemoteValue> ToValue(object? value) => value switch { // INCOMPLETE // Image
+            null              => new() { type = Dtype.Null },
+            float           x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Float32, shape = new int[0] },
+            double          x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Float64, shape = new int[0] },
+            sbyte           x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Int8, shape = new int[0] },
+            short           x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Int16, shape = new int[0] },
+            int             x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Int32, shape = new int[0] },
+            long            x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Int64, shape = new int[0] },
+            byte            x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Uint8, shape = new int[0] },
+            ushort          x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Uint16, shape = new int[0] },
+            uint            x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Uint32, shape = new int[0] },
+            ulong           x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Uint64, shape = new int[0] },
+            bool            x => new() { data = await Upload(new [] { x }.ToStream()), type = Dtype.Bool, shape = new int[0] },
+            float[]         x => new() { data = await Upload(x.ToStream()), type = Dtype.Float32, shape = new [] { x.Length } },
+            double[]        x => new() { data = await Upload(x.ToStream()), type = Dtype.Float64, shape = new [] { x.Length } },
+            sbyte[]         x => new() { data = await Upload(x.ToStream()), type = Dtype.Int8, shape = new [] { x.Length } },
+            short[]         x => new() { data = await Upload(x.ToStream()), type = Dtype.Int16, shape = new [] { x.Length } },
+            int[]           x => new() { data = await Upload(x.ToStream()), type = Dtype.Int32, shape = new [] { x.Length } },
+            long[]          x => new() { data = await Upload(x.ToStream()), type = Dtype.Int64, shape = new [] { x.Length } },
+            byte[]          x => new() { data = await Upload(x.ToStream()), type = Dtype.Uint8, shape = new [] { x.Length } },
+            ushort[]        x => new() { data = await Upload(x.ToStream()), type = Dtype.Uint16, shape = new [] { x.Length } },
+            uint[]          x => new() { data = await Upload(x.ToStream()), type = Dtype.Uint32, shape = new [] { x.Length } },
+            ulong[]         x => new() { data = await Upload(x.ToStream()), type = Dtype.Uint64, shape = new [] { x.Length } },
+            bool[]          x => new() { data = await Upload(x.ToStream()), type = Dtype.Bool, shape = new [] { x.Length } },
+            Tensor<float>   x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Float32, shape = x.shape },
+            Tensor<double>  x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Float64, shape = x.shape },
+            Tensor<sbyte>   x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Int8, shape = x.shape },
+            Tensor<short>   x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Int16, shape = x.shape },
+            Tensor<int>     x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Int32, shape = x.shape },
+            Tensor<long>    x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Int64, shape = x.shape },
+            Tensor<byte>    x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Uint8, shape = x.shape },
+            Tensor<ushort>  x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Uint16, shape = x.shape },
+            Tensor<uint>    x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Uint32, shape = x.shape },
+            Tensor<ulong>   x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Uint64, shape = x.shape },
+            Tensor<bool>    x => new() { data = await Upload(x.data.ToStream()), type = Dtype.Bool, shape = x.shape },
+            string          x => new() { data = await Upload(x.ToStream(), mime: @"text/plain"), type = Dtype.String },
+            IList           x => new() { data = await Upload(JsonConvert.SerializeObject(x).ToStream(), mime: @"application/json"), type = Dtype.List },
+            IDictionary     x => new() { data = await Upload(JsonConvert.SerializeObject(x).ToStream(), mime: @"application/json"), type = Dtype.Dict },
+            Image           x => new() { data = "", type = Dtype.Image },
+            Stream          x => new() { data = await Upload(x), type = Dtype.Binary },
             Enum            x => await ToValue(x.ToObject()),
+            RemoteValue     x => x,
             _                 => throw new InvalidOperationException($"Failed to serialize value '{value}' of type `{value.GetType()}` because it is not supported"),
         };
 
-        private async Task<object?> ToObject(Value value) { // INCOMPLETE // Image
+        private async Task<object?> ToObject(RemoteValue value) { // INCOMPLETE // Image
             if (value.type == Dtype.Null)
                 return null;
             using var stream = await Download(value.data!);
@@ -159,7 +160,7 @@ namespace Muna.Beta.Services {
 
         [Preserve, Serializable]
         private class RemotePrediction : Prediction {
-            public new Value[]? results;
+            public new RemoteValue[]? results;
         }
         #endregion
     }

package/Runtime/Beta/{Remote → Types}/Value.cs

@@ -5,7 +5,7 @@
 
 #nullable enable
 
-namespace Muna.Beta.Services {
+namespace Muna.Beta {
 
     using System;
     using System.IO;
@@ -18,7 +18,7 @@ namespace Muna.Beta.Services {
     /// Remote prediction value.
     /// </summary>
     [Preserve, Serializable]
-    internal class Value {
+    public sealed class RemoteValue {
 
         /// <summary>
         /// Value URL.

package/{Unity → Runtime/Beta}/Types.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 0c449c8b8a355457aa40b183e847e588
+guid: 13abad7ab83f14becbb10f8b4482e27a
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Runtime/Muna.cs

@@ -94,7 +94,7 @@ namespace Muna {
 
         #region --Operations--
         public readonly MunaClient client;
-        public const string Version = @"0.0.45";
+        public const string Version = @"0.0.47";
         internal const string URL = @"https://api.muna.ai/v1";
         #endregion
     }

package/Unity/API/PredictionCacheClient.cs

@@ -7,13 +7,12 @@
 
 namespace Muna.API {
 
-    using System;
     using System.Collections.Generic;
     using System.IO;
     using System.Linq;
     using System.Threading.Tasks;
     using UnityEngine;
-    using Newtonsoft.Json;
+    using Internal;
     using Services;
 
     /// <summary>
@@ -32,9 +31,8 @@ namespace Muna.API {
         /// <param name="cache">Prediction cache.</param>
         public PredictionCacheClient(
             string url,
-            string? accessKey,
-            List<CachedPrediction>? cache = default
-        ) : base(url, accessKey) => this.cache = cache ?? new();
+            string? accessKey
+        ) : base(url, accessKey) { }
 
         /// <summary>
         /// Perform a request to a Muna REST endpoint.
@@ -52,11 +50,9 @@ namespace Muna.API {
             Dictionary<string, string>? headers = default
         ) where T : class {
             // Check payload
-            var tag = payload?.TryGetValue(@"tag", out var t) ?? false ? t as string : null;
-            var clientId = payload?.TryGetValue(@"clientId", out var id) ?? false ? id as string : null;
-            var configurationId = payload?.TryGetValue(@"configurationId", out var configuration) ?? false ?
-                configuration as string :
-                null;
+            var tag = GetValue<string>(payload, @"tag");
+            var clientId = GetValue<string>(payload, @"clientId");
+            var configurationId = GetValue<string>(payload, @"configurationId");
             if (
                 method != @"POST"                       ||
                 path != @"/predictions"                 ||
@@ -65,38 +61,35 @@ namespace Muna.API {
                 string.IsNullOrEmpty(configurationId)
             )
                 return await base.Request<T>(method, path, payload, headers);
-            // Get cached prediction
-            var sanitizedTag = tag.Substring(1).Replace("/", "_");
-            var cachePath = Path.Combine(
-                PredictorCachePath,
+            // Get embedded prediction if available
+            var cache = MunaSettings.Instance!.cache;
+            var embeddedPrediction = cache.FirstOrDefault(p => 
+                p.tag == tag &&
+                MatchClientIds(p.clientId!, clientId)
+            );
+            // Load from prediction cache
+            if (PredictionCache.Get(
+                tag,
                 clientId,
                 configurationId,
-                $"{sanitizedTag}.json"
-            );
-            var cachedPrediction = TryLoadCachedPrediction(cachePath);
-            if (cachedPrediction != null)
+                embeddedPrediction?.resources,
+                out var cachedPrediction
+            ))
                 return cachedPrediction as T;
-            // Create prediction
-            var predictionId = cache.FirstOrDefault(p => p.tag == tag && p.clientId == clientId)?.id;
+            // Create prediction and cache
             var prediction = await base.Request<Prediction>(
                 method: @"POST",
                 path: @"/predictions",
-                payload: new () {
+                payload: new() {
                     [@"tag"] = tag,
                     [@"clientId"] = clientId,
                     [@"configurationId"] = configurationId,
-                    [@"predictionId"] = predictionId,
+                    [@"predictionId"] = embeddedPrediction?.id,
                 },
                 headers
             );
             prediction!.resources = await Task.WhenAll(prediction.resources.Select(GetCachedResource));
-            // Write
-            var predictionJson = JsonConvert.SerializeObject(
-                new CachedPrediction(prediction, clientId),
-                Formatting.Indented
-            );
-            Directory.CreateDirectory(Path.GetDirectoryName(cachePath));
-            File.WriteAllText(cachePath, predictionJson);
+            PredictionCache.Add(prediction.AsCached(clientId, configurationId));
             // Return
             return prediction as T;
         }
@@ -104,15 +97,9 @@ namespace Muna.API {
 
 
         #region --Operations--
-        private readonly List<CachedPrediction> cache;
-        private static string CacheRoot => Application.isEditor ?
-            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), @".fxn") :
-            Path.Combine(Application.persistentDataPath, @"fxn");
-        private static string ResourceCachePath => Path.Combine(CacheRoot, @"cache");
-        internal static string PredictorCachePath => Path.Combine(CacheRoot, @"predictors");
 
         private async Task<PredictionResource> GetCachedResource(PredictionResource resource) {
-            var path = PredictionService.GetResourcePath(resource, ResourceCachePath);
+            var path = PredictionService.GetResourcePath(resource, PredictionCache.ResourceCachePath);
             if (!File.Exists(path)) {
                 Directory.CreateDirectory(Path.GetDirectoryName(path));
                 using var dataStream = await Download(resource.url);
@@ -122,22 +109,28 @@ namespace Muna.API {
             return new PredictionResource { type = resource.type, url = $"file://{path}" };
         }
 
-        private static Prediction? TryLoadCachedPrediction(string path) {
-            if (!File.Exists(path))
-                return null;
-            var json = File.ReadAllText(path);
-            var prediction = JsonConvert.DeserializeObject<Prediction>(json)!;
-            var resources = prediction.resources.Select(res => new PredictionResource {
-                type = res.type,
-                url = $"file://{PredictionService.GetResourcePath(res, ResourceCachePath)}",
-                name = res.name
-            }).ToArray();
-            if (!resources.All(res => File.Exists(new Uri(res.url).LocalPath))) {
-                File.Delete(path);
-                return null;
+        private static T? GetValue<T>(
+            Dictionary<string, object?>? payload,
+            string key
+        ) {
+            if (payload?.TryGetValue(key, out var value) ?? false)
+                return (T?)value;
+            else
+                return default;
+        }
+
+        private static bool MatchClientIds(string a, string b) {
+            if (a == b)
+                return true;
+            if (a.Contains("android") && b.Contains("android")) {
+                var ARM32 = new[] { "armeabi-v7a", "armv7l", "armv8l" };
+                var ARM64 = new[] { "arm64", "aarch64", "armv8" };
+                if (ARM32.Any(s => a.Contains(s)) && ARM32.Any(s => b.Contains(s)))
+                    return true;
+                if (ARM64.Any(s => a.Contains(s)) && ARM64.Any(s => b.Contains(s)))
+                    return true;
             }
-            prediction.resources = resources;
-            return prediction;
+            return false;
         }
         #endregion
     }

package/Unity/Converters/Color.cs

@@ -0,0 +1,46 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Converters {
+
+    using System;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
+
+    /// <summary>
+    /// Convert an array field to a `Color`.
+    /// The array MUST contain three or four numbers.
+    /// </summary>
+    public sealed class ArrayToColorConverter : JsonConverter<Color> {
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Color value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.r, value.g, value.b, value.a };
+            obj.WriteTo(writer);
+        }
+
+        public override Color ReadJson(
+            JsonReader reader,
+            Type type,
+            Color existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Color(
+                r: (float)arr[0],
+                g: (float)arr[1],
+                b: (float)arr[2],
+                a: arr.Count > 3 ? (float)arr[3] : 1f
+            );
+        }
+    }
+}

package/Unity/Converters/Color.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 64482ee46d27541c0a981e4688bfeaad