ai.muna.muna 0.0.46 → 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,6 +7,7 @@ namespace Muna.Editor {
 
     using System.IO;
     using UnityEditor;
+    using Internal;
 
     internal static class MunaMenu {
 
@@ -32,10 +33,7 @@ namespace Muna.Editor {
 
         [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/README.md

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

package/Runtime/Muna.cs

@@ -94,7 +94,7 @@ namespace Muna {
 
         #region --Operations--
         public readonly MunaClient client;
-        public const string Version = @"0.0.46";
+        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/Internal/MunaSettings.cs

@@ -27,7 +27,7 @@ namespace Muna.Internal {
         /// Predictor cache.
         /// </summary>
         [field: SerializeField, HideInInspector]
-        public List<CachedPrediction> cache { get; internal set; } = new();
+        public List<PredictionCache.CachedPrediction> cache { get; internal set; } = new();
 
         /// <summary>
         /// Settings instance for this project.

package/Unity/Internal/PredictionCache.cs

@@ -0,0 +1,160 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Internal {
+
+    using System;
+    using System.IO;
+    using System.Security.Cryptography;
+    using System.Text;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Services;
+
+    internal static class PredictionCache {
+
+        #region --Types--
+        /// <summary>
+        /// Cached prediction.
+        /// </summary>
+        [Preserve, Serializable]
+        internal class CachedPrediction : Prediction {
+            public string? clientId;
+            public string? configurationId;
+
+            [Preserve]
+            public CachedPrediction() { }
+        }
+        #endregion
+
+
+        #region --Client API--
+        /// <summary>
+        /// Add a prediction to the cache.
+        /// </summary>
+        public static void Add(CachedPrediction prediction) {
+            var path = GetCachedPath(prediction);
+            var json = JsonConvert.SerializeObject(prediction, Formatting.Indented);
+            File.WriteAllText(path, json);
+        }
+
+        /// <summary>
+        /// Get a prediction from the cache.
+        /// </summary>
+        public static bool Get(
+            string tag,
+            string clientId,
+            string configurationId,
+            PredictionResource[]? embeddedResources,
+            out CachedPrediction? prediction
+        ) {
+            prediction = null;
+            // Check filesystem
+            var path = GetCachedPath(tag, clientId, configurationId);
+            if (!File.Exists(path))
+                return false;
+            // Load prediction
+            var json = File.ReadAllText(path);
+            var result = JsonConvert.DeserializeObject<CachedPrediction>(json)!;
+            // Check that resources are valid
+            if (!ResourcesAreValid(result.resources!, embeddedResources)) {
+                File.Delete(path);
+                return false;
+            }
+            // Pass
+            prediction = result;
+            return true;
+        }
+
+        /// <summary>
+        /// Remove a prediction from the cache.
+        /// </summary>
+        /// <param name="prediction"></param>
+        public static void Remove(CachedPrediction prediction) {
+            var path = GetCachedPath(prediction);
+            if (File.Exists(path))
+                File.Delete(path);
+        }
+
+        /// <summary>
+        /// Create a cached prediction from a prediction.
+        /// </summary>
+        public static CachedPrediction AsCached(
+            this Prediction prediction,
+            string? clientId = null,
+            string? configurationId = null
+        ) => new() {
+            id = prediction.id,
+            tag = prediction.tag,
+            created = prediction.created,
+            results = prediction.results,
+            latency = prediction.latency,
+            error = prediction.error,
+            logs = prediction.logs,
+            resources = prediction.resources,
+            configuration = prediction.configuration,
+            clientId = clientId,
+            configurationId = configurationId
+        };
+        #endregion
+
+
+        #region --Operations--
+        private static string CacheRoot => Application.isEditor ?
+            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), @".fxn") :
+            Path.Combine(Application.persistentDataPath, @"fxn");
+        internal static string ResourceCachePath => Path.Combine(CacheRoot, @"cache");
+        internal static string PredictorCachePath => Path.Combine(CacheRoot, @"predictors");
+
+        private static string GetCachedPath(CachedPrediction prediction) => GetCachedPath(
+            tag: prediction.tag,
+            clientId: prediction.clientId!,
+            configurationId: prediction.configurationId!
+        );
+
+        private static string GetCachedPath(
+            string tag,
+            string clientId,
+            string configurationId
+        ) {
+            if (!Directory.Exists(PredictorCachePath))
+                Directory.CreateDirectory(PredictorCachePath);
+            using var sha256 = new SHA256Managed();
+            var identifier = $"{tag}::{clientId}::{configurationId}";
+            var identifierData = Encoding.UTF8.GetBytes(identifier);
+            var hashData = sha256.ComputeHash(identifierData);
+            var hash = BitConverter.ToString(hashData).Replace("-", "").ToLower();
+            var path = Path.Combine(PredictorCachePath, $"{hash}.json");
+            return path;
+        }
+
+        private static bool ResourcesAreValid(
+            PredictionResource[] cachedResources,
+            PredictionResource[]? embeddedResources
+        ) {
+            if (embeddedResources != null && cachedResources.Length != embeddedResources.Length)
+                return false;
+            for (var idx = 0; idx < cachedResources.Length; ++idx) {
+                var cachedResource = cachedResources[idx];
+                var cachedPath = new Uri(cachedResource.url).LocalPath;
+                var embeddedPath = embeddedResources != null ?
+                    PredictionService.GetResourcePath(embeddedResources[idx], ResourceCachePath) :
+                    null;
+
+                Application.SetStackTraceLogType(LogType.Log, StackTraceLogType.None);
+                Debug.Log($"Cached path: {cachedPath} Embedded path: {embeddedPath}");
+
+                if (!File.Exists(cachedPath))
+                    return false;
+                if (embeddedPath != null && cachedPath != embeddedPath)
+                    return false;
+            }
+            return true;
+        }
+        #endregion
+    }
+}

package/Unity/Internal/PredictionCache.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d4e0b513297bf4d95935d63a7764c9ba

package/Unity/MunaUnity.cs

@@ -46,8 +46,7 @@ namespace Muna {
             var settings = MunaSettings.Instance!;
             var client = new PredictionCacheClient(
                 url ?? Muna.URL,
-                accessKey: accessKey ?? settings?.accessKey,
-                cache: settings?.cache
+                accessKey: accessKey ?? settings?.accessKey
             );
             return new Muna(client);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ai.muna.muna",
-    "version": "0.0.46",
+    "version": "0.0.47",
     "displayName": "Muna",
     "description": "Run AI inference in Unity Engine.",
     "unity": "2022.3",

package/Unity/Types/CachedPrediction.cs

@@ -1,36 +0,0 @@
-/* 
-*   Muna
-*   Copyright © 2025 NatML Inc. All rights reserved.
-*/
-
-#nullable enable
-
-namespace Muna {
-
-    using System;
-
-    /// <summary>
-    /// Cached prediction.
-    /// </summary>
-    [Preserve, Serializable]
-    internal class CachedPrediction : Prediction {
-
-        public string? clientId;
-
-        [Preserve]
-        public CachedPrediction() { }
-
-        public CachedPrediction(Prediction prediction, string clientId) {
-            this.id = prediction.id;
-            this.tag = prediction.tag;
-            this.created = prediction.created;
-            this.results = prediction.results;
-            this.latency = prediction.latency;
-            this.error = prediction.error;
-            this.logs = prediction.logs;
-            this.resources = prediction.resources;
-            this.configuration = prediction.configuration;
-            this.clientId = clientId;
-        }
-    }
-}

package/Unity/Types/CachedPrediction.cs.meta

@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: 7b5e913e3117a442abc1345c156f136d
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

package/Unity/Types.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 0c449c8b8a355457aa40b183e847e588
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: