npm - ai.muna.muna - Versions diffs - 0.0.45 → 0.0.46 - Mend

ai.muna.muna 0.0.45 → 0.0.46

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

package/Editor/MunaMenu.cs +7 -7
package/Plugins/Android/Muna.aar +0 -0
package/Plugins/macOS/Function.dylib.meta +26 -25
package/README.md +1 -1
package/Runtime/Beta/OpenAI/SpeechService.cs +6 -0
package/Runtime/Beta/OpenAI/Types.cs +0 -1
package/Runtime/Beta/Remote/RemotePredictionService.cs +43 -42
package/Runtime/Beta/{Remote → Types}/Value.cs +2 -2
package/Runtime/Beta/Types.meta +8 -0
package/Runtime/Muna.cs +1 -1
package/Unity/Converters/Color.cs +46 -0
package/Unity/Converters/Color.cs.meta +2 -0
package/Unity/Converters/Rect.cs +230 -0
package/Unity/Converters/Rect.cs.meta +2 -0
package/Unity/Converters/Vector2.cs +44 -0
package/Unity/Converters/Vector2.cs.meta +2 -0
package/Unity/Converters/Vector3.cs +45 -0
package/Unity/Converters/Vector3.cs.meta +2 -0
package/Unity/Converters/Vector4.cs +46 -0
package/Unity/Converters/Vector4.cs.meta +2 -0
package/Unity/Converters.meta +8 -0
package/Unity/MunaUnity.cs +67 -18
package/package.json +1 -1
/package/Runtime/Beta/{Remote → Types}/Value.cs.meta +0 -0

package/Editor/MunaMenu.cs CHANGED Viewed

@@ -12,25 +12,25 @@ namespace Muna.Editor {
         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,

package/Plugins/Android/Muna.aar CHANGED Viewed

Binary file

package/Plugins/macOS/Function.dylib.meta CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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.46"
   }
 }
 ```

package/Runtime/Beta/OpenAI/SpeechService.cs CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 RENAMED Viewed

@@ -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/Runtime/Beta/Types.meta ADDED Viewed

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

package/Runtime/Muna.cs CHANGED Viewed

@@ -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.46";
         internal const string URL = @"https://api.muna.ai/v1";
         #endregion
     }

package/Unity/Converters/Color.cs ADDED Viewed

@@ -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 ADDED Viewed

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

package/Unity/Converters/Rect.cs ADDED Viewed

@@ -0,0 +1,230 @@
+/*
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+#nullable enable
+namespace Muna.Converters {
+    using System;
+    using System.Runtime.Serialization;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Converters;
+    using Newtonsoft.Json.Linq;
+    /// <summary>
+    /// Box format.
+    /// </summary>
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum BoxFormat : int {
+        /// <summary>
+        /// Boxes are represented via corners: x1, y1 being top left and x2, y2 being bottom right.
+        /// </summary>
+        [EnumMember(Value = @"xyxy")]
+        XYXY = 1,
+        /// <summary>
+        /// Boxes are represented via corner, width and height: x1, y2 being top left.
+        /// </summary>
+        [EnumMember(Value = @"xywh")]
+        XYWH = 2,
+        /// <summary>
+        /// Boxes are represented via center, width, and height.
+        /// </summary>
+        [EnumMember(Value = @"cxcywh")]
+        CxCyWH = 3,
+        /// <summary>
+        /// Boxes are represented via corners:
+        /// - x1, y1 being top left
+        /// - x2, y2 top right
+        /// - x3, y3 bottom right
+        /// - x4, y4 bottom left
+        /// </summary>
+        [EnumMember(Value = @"xyxyxyxy")]
+        XYXYXYXY = 4,
+    }
+    /// <summary>
+    /// Convert an object field to a `Rect`.
+    /// </summary>
+    public sealed class ObjectToRectConverter : JsonConverter<Rect> {
+        private readonly BoxFormat format;
+        private readonly string[] fieldNames;
+        /// <summary>
+        /// Create a converter with the provided box format.
+        /// </summary>
+        /// <param name="format">Box format to parse.</param>
+        public ObjectToRectConverter(BoxFormat format): this(
+            format,
+            GetReferenceFieldNames(format)
+        ) { }
+        /// <summary>
+        /// Create a converter with the provided box format and corresponding field names.
+        /// </summary>
+        /// <param name="format">Box format to parse.</param>
+        /// <param name="fieldNames">Field names that correspond to the chosen format.</param>
+        public ObjectToRectConverter(BoxFormat format, string[] fieldNames) {
+            this.format = format;
+            this.fieldNames = fieldNames;
+        }
+        public override void WriteJson(
+            JsonWriter writer,
+            Rect value,
+            JsonSerializer serializer
+        ) {
+            var values = GetRectValues(value, format);
+            var obj = new JObject();
+            for (var i = 0; i < fieldNames.Length; ++i)
+                obj[fieldNames[i]] = values[i];
+            obj.WriteTo(writer);
+        }
+        public override Rect ReadJson(
+            JsonReader reader,
+            Type type,
+            Rect existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var obj = JObject.Load(reader);
+            return format switch {
+                BoxFormat.XYXY => Rect.MinMaxRect(
+                    xmin: GetFieldValue(obj, fieldNames[0]),
+                    ymin: GetFieldValue(obj, fieldNames[1]),
+                    xmax: GetFieldValue(obj, fieldNames[2]),
+                    ymax: GetFieldValue(obj, fieldNames[3])
+                ),
+                BoxFormat.XYWH => new Rect(
+                    x: GetFieldValue(obj, fieldNames[0]),
+                    y: GetFieldValue(obj, fieldNames[1]),
+                    width: GetFieldValue(obj, fieldNames[2]),
+                    height: GetFieldValue(obj, fieldNames[3])
+                ),
+                BoxFormat.CxCyWH => GetCenterRect(obj),
+                BoxFormat.XYXYXYXY => Rect.MinMaxRect(
+                    xmin: GetFieldValue(obj, fieldNames[0]),  // left
+                    ymin: GetFieldValue(obj, fieldNames[1]),  // top
+                    xmax: GetFieldValue(obj, fieldNames[4]),  // right
+                    ymax: GetFieldValue(obj, fieldNames[5])   // bottom
+                ),
+                _ => throw new JsonSerializationException($"Failed to read `Rect` from JSON object because of unsupported format: {format}")
+            };
+        }
+        private Rect GetCenterRect(JObject obj) {
+            var cx = GetFieldValue(obj, fieldNames[0]);
+            var cy = GetFieldValue(obj, fieldNames[1]);
+            var w = GetFieldValue(obj, fieldNames[2]);
+            var h = GetFieldValue(obj, fieldNames[3]);
+            var center = new Vector2(cx, cy);
+            var size = new Vector2(w, h);
+            return new Rect(center - 0.5f * size, size);
+        }
+        private float GetFieldValue(
+            JObject obj,
+            string name
+        ) {
+            if (!obj.TryGetValue(name, StringComparison.InvariantCulture, out var value))
+                throw new JsonSerializationException($"Missing '{name}' field for {format} box.");
+            return (float)value;
+        }
+        internal static float[] GetRectValues(
+            in Rect rect,
+            BoxFormat format
+        ) => format switch {
+            BoxFormat.XYXY      => new[] { rect.xMin, rect.yMin, rect.xMax, rect.yMax },
+            BoxFormat.XYWH      => new[] { rect.xMin, rect.yMin, rect.width, rect.height },
+            BoxFormat.CxCyWH    => new[] { rect.center.x, rect.center.y, rect.width, rect.height },
+            BoxFormat.XYXYXYXY  => new[] {
+                rect.xMin, rect.yMin, // top-left
+                rect.xMax, rect.yMin, // top-right
+                rect.xMax, rect.yMax, // bottom-right
+                rect.xMin, rect.yMax  // bottom-left
+            },
+            _                   => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+        private static string[] GetReferenceFieldNames(BoxFormat format) => format switch {
+            BoxFormat.XYXY      => new[] { @"x_min", @"y_min", @"x_max", @"y_max" },
+            BoxFormat.XYWH      => new[] { @"x", @"y", @"width", @"height" },
+            BoxFormat.CxCyWH    => new[] { @"x_center", @"y_center", @"width", @"height" },
+            BoxFormat.XYXYXYXY  => new[] { @"x1", @"y1", @"x2", @"y2", @"x3", @"y3", @"x4", @"y4" },
+            _                   => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+    }
+    /// <summary>
+    /// Convert an array field to a `Rect`.
+    /// The array MUST contain numbers, and have the required count depending on the box format.
+    /// </summary>
+    public sealed class ArrayToRectConverter : JsonConverter<Rect> {
+        private readonly BoxFormat format;
+        /// <summary>
+        /// Create a converter for the provided box format.
+        /// </summary>
+        /// <param name="format">Box format to parse.</param>
+        public ArrayToRectConverter(BoxFormat format) => this.format = format;
+        public override void WriteJson(
+            JsonWriter writer,
+            Rect value,
+            JsonSerializer serializer
+        ) {
+            var values = ObjectToRectConverter.GetRectValues(value, format);
+            var arr = new JArray(values);
+            arr.WriteTo(writer);
+        }
+        public override Rect ReadJson(
+            JsonReader reader,
+            Type type,
+            Rect existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            var expected = ExpectedCount(format);
+            if (arr.Count != expected)
+                throw new JsonSerializationException($"Expected {expected} numbers for {format} box but got {arr.Count}.");
+            var data = arr.ToObject<float[]>()!;
+            return format switch {
+                BoxFormat.XYXY => Rect.MinMaxRect(
+                    xmin: data[0],
+                    ymin: data[1],
+                    xmax: data[2],
+                    ymax: data[3]
+                ),
+                BoxFormat.XYWH => new Rect(
+                    x: data[0],
+                    y: data[1],
+                    width: data[2],
+                    height: data[3]
+                ),
+                BoxFormat.CxCyWH => new Rect(
+                    x: data[0] - 0.5f * data[2],
+                    y: data[1] * 0.5f - data[3],
+                    width: data[2],
+                    height: data[3]
+                ),
+                _ => throw new JsonSerializationException($"Failed to read `Rect` from JSON array because of unsupported format: {format}")
+            };
+        }
+        private static int ExpectedCount(BoxFormat format) => format switch {
+            BoxFormat.XYXY      => 4,
+            BoxFormat.XYWH      => 4,
+            BoxFormat.CxCyWH    => 4,
+            BoxFormat.XYXYXYXY  => 8,
+            _                   => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+    }
+}

package/Unity/Converters/Rect.cs.meta ADDED Viewed

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

package/Unity/Converters/Vector2.cs ADDED Viewed

@@ -0,0 +1,44 @@
+/*
+*   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 `Vector2`.
+    /// The array MUST contain exactly two numbers.
+    /// </summary>
+    public sealed class ArrayToVector2Converter : JsonConverter<Vector2> {
+        public override void WriteJson(
+            JsonWriter writer,
+            Vector2 value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.x, value.y };
+            obj.WriteTo(writer);
+        }
+        public override Vector2 ReadJson(
+            JsonReader reader,
+            Type type,
+            Vector2 existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Vector2(
+                x: (float)arr[0],
+                y: (float)arr[1]
+            );
+        }
+    }
+}

package/Unity/Converters/Vector2.cs.meta ADDED Viewed

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

package/Unity/Converters/Vector3.cs ADDED Viewed

@@ -0,0 +1,45 @@
+/*
+*   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 `Vector3`.
+    /// The array MUST contain exactly three numbers.
+    /// </summary>
+    public sealed class ArrayToVector3Converter : JsonConverter<Vector3> {
+        public override void WriteJson(
+            JsonWriter writer,
+            Vector3 value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.x, value.y, value.z };
+            obj.WriteTo(writer);
+        }
+        public override Vector3 ReadJson(
+            JsonReader reader,
+            Type type,
+            Vector3 existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Vector3(
+                x: (float)arr[0],
+                y: (float)arr[1],
+                z: (float)arr[2]
+            );
+        }
+    }
+}

package/Unity/Converters/Vector3.cs.meta ADDED Viewed

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

package/Unity/Converters/Vector4.cs ADDED Viewed

@@ -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 `Vector4`.
+    /// The array MUST contain exactly four numbers.
+    /// </summary>
+    public sealed class ArrayToVector4Converter : JsonConverter<Vector4> {
+        public override void WriteJson(
+            JsonWriter writer,
+            Vector4 value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.x, value.y, value.z, value.w };
+            obj.WriteTo(writer);
+        }
+        public override Vector4 ReadJson(
+            JsonReader reader,
+            Type type,
+            Vector4 existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Vector4(
+                x: (float)arr[0],
+                y: (float)arr[1],
+                z: (float)arr[2],
+                w: (float)arr[3]
+            );
+        }
+    }
+}

package/Unity/Converters/Vector4.cs.meta ADDED Viewed

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

package/Unity/Converters.meta ADDED Viewed

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

package/Unity/MunaUnity.cs CHANGED Viewed

@@ -20,9 +20,11 @@ namespace Muna {
     using System;
     using System.Collections.Generic;
+    using System.Text.RegularExpressions;
     using UnityEngine;
     using Unity.Collections.LowLevel.Unsafe;
     using API;
+    using Beta.OpenAI;
     using Internal;
     /// <summary>
@@ -61,34 +63,34 @@ namespace Muna {
             this Texture2D texture,
             byte[]? pixelBuffer = null
         ) {
+            // Check texture
             if (texture == null)
                 throw new ArgumentNullException(nameof(texture));
+            // Check that texture is readable
             if (!texture.isReadable)
                 throw new InvalidOperationException(@"Texture cannot be converted to a Muna image because it is not readable");
-            var FormatChannelMap = new Dictionary<TextureFormat, int> {
-                [TextureFormat.R8] = 1,
-                [TextureFormat.Alpha8] = 1,
-                [TextureFormat.RGB24] = 3,
-                [TextureFormat.RGBA32] = 4,
-            };
-            if (!FormatChannelMap.TryGetValue(texture.format, out var channels))
-                throw new InvalidOperationException($"Texture cannot be converted to a Muna image because it has unsupported format: {texture.format}");
+            // Allocate buffer
+            var channels = TextureFormatToImageChannels.GetValueOrDefault(texture.format, 4);
             var rowStride = texture.width * channels;
             var bufferSize = rowStride * texture.height;
             pixelBuffer ??= new byte[bufferSize];
             if (pixelBuffer.Length < bufferSize)
                 throw new InvalidOperationException($"Texture cannot be converted to a Muna image because pixel buffer length was expected to be greater than or equal to {bufferSize} but got {pixelBuffer.Length}");
-            fixed (void* dst = pixelBuffer)
+            // Copy
+            var colorData = !TextureFormatToImageChannels.ContainsKey(texture.format) ? texture.GetPixels32() : null;
+            fixed (void* dst = pixelBuffer, colors = colorData) {
+                var src = colors == null ? texture.GetRawTextureData<byte>().GetUnsafePtr() : colors;
                 UnsafeUtility.MemCpyStride(
                     dst,
                     rowStride,
-                    (byte*)texture.GetRawTextureData<byte>().GetUnsafePtr() + (rowStride * (texture.height - 1)),
+                    (byte*)src + (rowStride * (texture.height - 1)),
                     -rowStride,
                     rowStride,
                     texture.height
                 );
-            var image = new Image(pixelBuffer, texture.width, texture.height, channels);
-            return image;
+            }
+            // Return
+            return new Image(pixelBuffer, texture.width, texture.height, channels);
         }
         /// <summary>
@@ -101,12 +103,7 @@ namespace Muna {
             this Image image,
             Texture2D? texture = null
         ) {
-            var ChannelFormatMap = new Dictionary<int, TextureFormat> {
-                [1] = TextureFormat.Alpha8,
-                [3] = TextureFormat.RGB24,
-                [4] = TextureFormat.RGBA32
-            };
-            if (!ChannelFormatMap.TryGetValue(image.channels, out var format))
+            if (!ImageChannelsToTextureFormat.TryGetValue(image.channels, out var format))
                 throw new InvalidOperationException($"Image cannot be converted to a Texture2D because it has unsupported channel count: {image.channels}");
             texture = texture != null ? texture : new Texture2D(image.width, image.height, format, false);
             if (texture.width != image.width || texture.height != image.height || texture.format != format)
@@ -124,6 +121,58 @@ namespace Muna {
             texture.Apply();
             return texture;
         }
+        /// <summary>
+        /// Convert a `BinaryData` containing linear PCM audio into an audio clip.
+        /// </summary>
+        /// <param name="data">Binary data containing linear PCM audio.</param>
+        /// <returns>Audio clip.</returns>
+        public static unsafe AudioClip ToAudioClip(this BinaryData data) {
+            // Check that this contains LPCM data
+            if (string.IsNullOrEmpty(data.MediaType) || !data.MediaType.StartsWith(@"audio/pcm"))
+                throw new ArgumentException($"Failed to create audio clip from binary data because media type was expected to be 'audio/pcm' but got: '{data.MediaType}'");
+            // Match sample rate and channel count
+            var rateMatch = Regex.Match(data.MediaType, @"rate=(\d+)");
+            var channelsMatch = Regex.Match(data.MediaType, @"channels=(\d+)");
+            if (!rateMatch.Success || !channelsMatch.Success)
+                throw new ArgumentException($"Failed to create audio clip from binary data because media type is invalid: '{data.MediaType}'");
+            // Parse
+            if (!int.TryParse(rateMatch.Groups[1].Value, out var sampleRate))
+                throw new ArgumentException($"Failed to create audio clip from binary data because sample rate is invalid: '{rateMatch.Value}'");
+            if (!int.TryParse(channelsMatch.Groups[1].Value, out var channelCount))
+                throw new ArgumentException($"Failed to create audio clip from binary data because channel count is invalid: '{channelsMatch.Value}'");
+            // Create clip
+            var sampleCount = data.Length / sizeof(float);
+            var frameCount = sampleCount / channelCount;
+            var clip = AudioClip.Create(
+                "audio",
+                lengthSamples: frameCount,
+                channels: channelCount,
+                frequency: sampleRate,
+                stream: false
+            );
+            // Copy data
+            var samples = new float[sampleCount];
+            Buffer.BlockCopy(data.ToArray(), 0, samples, 0, data.Length);
+            clip.SetData(samples, 0);
+            // Return
+            return clip;
+        }
+        #endregion
+        #region --Operations--
+        private static readonly Dictionary<TextureFormat, int> TextureFormatToImageChannels = new() {
+            [TextureFormat.R8] = 1,
+            [TextureFormat.Alpha8] = 1,
+            [TextureFormat.RGB24] = 3,
+            [TextureFormat.RGBA32] = 4,
+        };
+        private static readonly Dictionary<int, TextureFormat> ImageChannelsToTextureFormat = new() {
+            [1] = TextureFormat.Alpha8,
+            [3] = TextureFormat.RGB24,
+            [4] = TextureFormat.RGBA32,
+        };
         #endregion
     }
 }

package/package.json CHANGED Viewed

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

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

File without changes