ai.muna.muna 0.0.44 → 0.0.45

package/Editor/MunaMenu.cs

@@ -5,12 +5,13 @@
 
 namespace Muna.Editor {
 
+    using System.IO;
     using UnityEditor;
 
     internal static class MunaMenu {
 
         private const int BasePriority = -50;
-        
+
         [MenuItem(@"Muna/Muna " + Muna.Version, false, BasePriority)]
         private static void Version() { }
 
@@ -28,5 +29,14 @@ namespace Muna.Editor {
 
         [MenuItem(@"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)]
+        private static void ClearPredictorCache() {
+            Directory.Delete(
+                global::Muna.API.PredictionCacheClient.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.44"
+    "ai.muna.muna": "0.0.45"
   }
 }
 ```

package/Runtime/API/DotNetClient.cs

@@ -26,9 +26,6 @@ namespace Muna.API {
         /// </summary>
         /// <param name="url">Muna API URL.</param>
         /// <param name="accessKey">Muna access key.</param>
-        /// <param name="clientId">Client identifier.</param>
-        /// <param name="deviceId">Device model identifier.</param>
-        /// <param name="cachePath">Prediction resource cache path.</param>
         public DotNetClient(
             string url,
             string? accessKey = default

package/Runtime/Beta/BetaClient.cs

@@ -8,7 +8,10 @@
 namespace Muna.Beta {
 
     using API;
+    using OpenAI;
     using Services;
+    using PredictorService = global::Muna.Services.PredictorService;
+    using EdgePredictionService = global::Muna.Services.PredictionService;
 
     /// <summary>
     /// Client for incubating features.
@@ -20,13 +23,23 @@ namespace Muna.Beta {
         /// Make predictions.
         /// </summary>
         public readonly PredictionService Predictions;
+
+        /// <summary>
+        /// OpenAI client.
+        /// </summary>
+        public readonly OpenAIClient OpenAI;
         #endregion
 
 
         #region --Operations--
 
-        internal BetaClient(MunaClient client) {
+        internal BetaClient(
+            MunaClient client,
+            PredictorService predictors,
+            EdgePredictionService predictions
+        ) {
             this.Predictions = new PredictionService(client);
+            this.OpenAI = new OpenAIClient(predictors, predictions, Predictions.Remote);
         }
         #endregion
     }

package/Runtime/Beta/OpenAI/AudioService.cs

@@ -0,0 +1,38 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Beta.OpenAI {
+
+    using Services;
+    using PredictorService = global::Muna.Services.PredictorService;
+    using EdgePredictionService = global::Muna.Services.PredictionService;
+
+    /// <summary>
+    /// Create speech and transcriptions.
+    /// </summary>
+    public sealed class AudioService {
+
+        #region --Client API--
+        /// <summary>
+        /// Create speech.
+        /// </summary>
+        public readonly SpeechService Speech;
+        #endregion
+
+
+        #region --Operations--
+
+        internal AudioService(
+            PredictorService predictors,
+            EdgePredictionService predictions,
+            RemotePredictionService remotePredictions
+        ) {
+            Speech = new SpeechService(predictors, predictions, remotePredictions);
+        }
+        #endregion
+    }
+}

package/Runtime/Beta/OpenAI/AudioService.cs.meta

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

package/Runtime/Beta/OpenAI/ChatService.cs

@@ -0,0 +1,38 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Beta.OpenAI {
+
+    using Services;
+    using PredictorService = global::Muna.Services.PredictorService;
+    using EdgePredictionService = global::Muna.Services.PredictionService;
+
+    /// <summary>
+    /// Create chat conversations.
+    /// </summary>
+    public sealed class ChatService {
+
+        #region --Client API--
+        /// <summary>
+        /// Create completions.
+        /// </summary>
+        public readonly ChatCompletionService Completions;
+        #endregion
+
+
+        #region --Operations--
+
+        internal ChatService(
+            PredictorService predictors,
+            EdgePredictionService predictions,
+            RemotePredictionService remotePredictions
+        ) {
+            Completions = new ChatCompletionService(predictors, predictions, remotePredictions);
+        }
+        #endregion
+    }
+}

package/Runtime/Beta/OpenAI/ChatService.cs.meta

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

package/Runtime/Beta/OpenAI/CompletionService.cs

@@ -0,0 +1,117 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Beta.OpenAI {
+
+    using System;
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using Newtonsoft.Json.Linq;
+    using Services;
+    using PredictorService = global::Muna.Services.PredictorService;
+    using EdgePredictionService = global::Muna.Services.PredictionService;
+
+    /// <summary>
+    /// Create chat conversations.
+    /// </summary>
+    public sealed class ChatCompletionService {
+
+        #region --Client API--
+        /// <summary>
+        /// Create a chat completion.
+        /// </summary>
+        /// <param name="model">Chat model predictor tag.</param>
+        /// <param name="messages">Messages comprising the conversation so far.</param>
+        /// <param name="maxTokens">Maximum output tokens.</param>
+        /// <param name="acceleration">Prediction acceleration.</param>
+        public async Task<ChatCompletion> Create(
+            string model,
+            ChatMessage[] messages,
+            int? maxTokens = null,
+            object? acceleration = null
+        ) {
+            var prediction = await CreatePrediction(
+                model,
+                new() {
+                    [@"messages"] = messages,
+                    [@"max_tokens"] = maxTokens
+                },
+                acceleration: acceleration ?? Acceleration.Auto
+            );
+            if (prediction.error != null)
+                throw new InvalidOperationException(prediction.error);
+            var completion = (prediction.results![0] as JObject)!.ToObject<ChatCompletion>()!;
+            return completion;
+        }
+
+        /// <summary>
+        /// Stream a chat completion.
+        /// </summary>
+        /// <param name="model">Chat model predictor tag.</param>
+        /// <param name="messages">Messages comprising the conversation so far.</param>
+        /// <param name="maxTokens">Maximum output tokens.</param>
+        /// <param name="acceleration">Prediction acceleration.</param>
+        public async IAsyncEnumerable<ChatCompletionChunk> Stream(
+            string model,
+            ChatMessage[] messages,
+            int? maxTokens = null,
+            object? acceleration = null
+        ) {
+            var stream = StreamPrediction(
+                model,
+                new() {
+                    [@"messages"] = messages,
+                    [@"max_tokens"] = maxTokens
+                },
+                acceleration: acceleration ?? Acceleration.Auto
+            );
+            await foreach (var prediction in stream) {
+                if (prediction.error != null)
+                    throw new InvalidOperationException(prediction.error);
+                var chunk = (prediction.results![0] as JObject)!.ToObject<ChatCompletionChunk>()!;
+                yield return chunk;
+            }
+        }
+        #endregion
+
+
+        #region --Operations--
+        private readonly PredictorService predictors;
+        private readonly EdgePredictionService predictions;
+        private readonly RemotePredictionService remotePredictions;
+
+        internal ChatCompletionService(
+            PredictorService predictors,
+            EdgePredictionService predictions,
+            RemotePredictionService remotePredictions
+        ) {
+            this.predictors = predictors;
+            this.predictions = predictions;
+            this.remotePredictions = remotePredictions;
+        }
+
+        private Task<Prediction> CreatePrediction(
+            string tag,
+            Dictionary<string, object?> inputs,
+            object acceleration
+        ) => acceleration switch {
+            Acceleration acc => predictions.Create(tag, inputs, acc),
+            RemoteAcceleration acc => remotePredictions.Create(tag, inputs, acc),
+            _ => throw new InvalidOperationException($"Cannot create {tag} prediction because acceleration is invalid: {acceleration}")
+        };
+
+        private IAsyncEnumerable<Prediction> StreamPrediction(
+            string tag,
+            Dictionary<string, object?> inputs,
+            object acceleration
+        ) => acceleration switch {
+            Acceleration acc => predictions.Stream(tag, inputs, acc),
+            _ => throw new InvalidOperationException($"Cannot stream {tag} prediction because acceleration is invalid: {acceleration}")
+        };
+        #endregion
+    }
+}

package/Runtime/Beta/OpenAI/CompletionService.cs.meta

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

package/Runtime/Beta/OpenAI/EmbeddingService.cs

@@ -0,0 +1,252 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Beta.OpenAI {
+
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Runtime.Serialization;
+    using System.Threading.Tasks;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Converters;
+    using Newtonsoft.Json.Linq;
+    using Services;
+    using PredictorService = global::Muna.Services.PredictorService;
+    using EdgePredictionService = global::Muna.Services.PredictionService;
+
+    /// <summary>
+    /// Create embeddings.
+    /// </summary>
+    public sealed class EmbeddingService {
+
+        #region --Client API--
+        /// <summary>
+        /// Embedding encoding format.
+        /// </summary>
+        [JsonConverter(typeof(StringEnumConverter))]
+        public enum EncodingFormat {
+            /// <summary>
+            /// Float array.
+            /// </summary>
+            [EnumMember(Value = @"float")]
+            Float = 1,
+            /// <summary>
+            /// Base64 string.
+            /// </summary>
+            [EnumMember(Value = @"base64")]
+            Base64 = 2
+        }
+
+        /// <summary>
+        /// Create an embedding vector representing the input text.
+        /// </summary>
+        /// <param name="input">Input text to embed. The input must not exceed the max input tokens for the model.</param>
+        /// <param name="model">Embedding model predictor tag.</param>
+        /// <param name="dimensions">The number of dimensions the resulting output embeddings should have. Only supported by Matryoshka embedding models.</param>
+        /// <param name="encodingFormat">The format to return the embeddings in.</param>
+        /// <param name="acceleration">Prediction acceleration.</param>
+        /// <returns>Embeddings.</returns>
+        public Task<CreateEmbeddingResponse> Create(
+            string model,
+            string input,
+            int? dimensions = null,
+            EncodingFormat encodingFormat = EncodingFormat.Float,
+            object? acceleration = null
+        ) => Create(
+            model,
+            new[] { input },
+            dimensions: dimensions,
+            encodingFormat: encodingFormat,
+            acceleration: acceleration
+        );
+
+        /// <summary>
+        /// Create an embedding vector representing the input text.
+        /// </summary>
+        /// <param name="input">Input text to embed. The input must not exceed the max input tokens for the model.</param>
+        /// <param name="model">Embedding model predictor tag.</param>
+        /// <param name="dimensions">The number of dimensions the resulting output embeddings should have. Only supported by Matryoshka embedding models.</param>
+        /// <param name="encodingFormat">The format to return the embeddings in.</param>
+        /// <param name="acceleration">Prediction acceleration.</param>
+        /// <returns>Embeddings.</returns>
+        public async Task<CreateEmbeddingResponse> Create(
+            string model,
+            string[] input,
+            int? dimensions = null,
+            EncodingFormat encodingFormat = EncodingFormat.Float,
+            object? acceleration = null
+        ) {
+            // Ensure we have a delegate
+            if (!cache.ContainsKey(model)) {
+                var @delegate = await CreateEmbeddingDelegate(model);
+                cache.Add(model, @delegate);
+            }
+            // Make prediction
+            var handler = cache[model];
+            var result = await handler(
+                model,
+                input,
+                dimensions,
+                encodingFormat,
+                acceleration: acceleration ?? Acceleration.Auto
+            );
+            // Return
+            return result;
+        }
+        #endregion
+
+
+        #region --Operations--
+        private readonly PredictorService predictors;
+        private readonly EdgePredictionService predictions;
+        private readonly RemotePredictionService remotePredictions;
+        private readonly Dictionary<string, EmbeddingDelegate> cache;
+        private delegate Task<CreateEmbeddingResponse> EmbeddingDelegate(
+            string model,
+            string[] input,
+            int? dimensions,
+            EncodingFormat encodingFormat,
+            object acceleration
+        );
+
+        internal EmbeddingService(
+            PredictorService predictors,
+            EdgePredictionService predictions,
+            RemotePredictionService remotePredictions
+        ) {
+            this.predictors = predictors;
+            this.predictions = predictions;
+            this.remotePredictions = remotePredictions;
+            this.cache = new();
+        }
+
+        private async Task<EmbeddingDelegate> CreateEmbeddingDelegate(string tag) {
+            // Retrieve predictor
+            var predictor = await predictors.Retrieve(tag);
+            if (predictor == null)
+                throw new ArgumentException($"{tag} cannot be used for OpenAI embedding API because the predictor could not be found.");
+            // Get required inputs
+            var signature = predictor.signature!;
+            var requiredInputParams = signature.inputs.Where(parameter => parameter.optional == false).ToArray();
+            if (requiredInputParams.Length != 1)
+                throw new InvalidOperationException($"{tag} cannot be used with OpenAI embedding API because it does not have exactly one required input parameter.");
+            // Check the text input parameter
+            var inputParam = requiredInputParams[0];
+            if (inputParam.type != Dtype.List)
+                throw new InvalidOperationException($"{tag} cannot be used with OpenAI embedding API because it does not have the required text embedding input parameter.");
+            // Get the Matryoshka dim parameter (optional)
+            var matryoshkaParam = signature.inputs.FirstOrDefault(parameter =>
+                new[] {
+                    Dtype.Int8, Dtype.Int16, Dtype.Int32, Dtype.Int64,
+                    Dtype.Uint8, Dtype.Uint16, Dtype.Uint32, Dtype.Uint64
+                }.Contains(parameter.type) &&
+                parameter.denotation == "embedding.dims"
+            );
+            // Get the embedding output parameter
+            var (embeddingParamIdx, embeddingParam) = signature.outputs
+                .Select((parameter, idx) => (idx, parameter))
+                .Where(pair =>
+                    pair.parameter.type == Dtype.Float32 &&
+                    pair.parameter.denotation == "embedding"
+                )
+                .FirstOrDefault();
+            if (embeddingParam == null)
+                throw new InvalidOperationException($"{tag} cannot be used with OpenAI embedding API because it has no outputs with an `embedding` denotation.");
+            // Get the index of the usage output (optional)
+            var (usageParamIdx, usageParam) = signature.outputs
+                .Select((parameter, idx) => (idx, parameter))
+                .Where(pair =>
+                    pair.parameter.type == Dtype.Dict &&
+                    pair.parameter.denotation == "openai.embedding.usage"
+                )
+                .FirstOrDefault();
+            // Create delegate
+            EmbeddingDelegate result = async (
+                string model,
+                string[] input,
+                int? dimensions,
+                EncodingFormat encodingFormat,
+                object acceleration
+            ) => {
+                // Build prediction input map
+                var inputMap = new Dictionary<string, object?> {
+                    [inputParam.name] = input
+                };
+                if (dimensions != null && matryoshkaParam != null)
+                    inputMap[matryoshkaParam.name] = dimensions.Value;
+                // Create prediction
+                var prediction = await CreatePrediction(
+                    model,
+                    inputs: inputMap,
+                    acceleration: acceleration
+                );
+                // Check for error
+                if (prediction.error != null)
+                    throw new InvalidOperationException(prediction.error);
+                // Check returned embedding
+                var rawEmbeddingMatrix = prediction.results![embeddingParamIdx]!;
+                if (!(rawEmbeddingMatrix is Tensor<float> embeddingMatrix))
+                    throw new InvalidOperationException($"{tag} cannot be used with OpenAI embedding API because it returned an object of type {rawEmbeddingMatrix.GetType()} instead of an embedding matrix.");
+                if (embeddingMatrix.shape.Length != 2) {
+                    var shapeStr = "(" + string.Join(",", embeddingMatrix.shape) + ")";
+                    throw new InvalidOperationException($"{tag} cannot be used with OpenAI embedding API because it returned an embedding matrix with invalid shape: {shapeStr}");
+                }
+                // Create embedding response
+                var embeddings = Enumerable
+                    .Range(0, embeddingMatrix.shape[0])
+                    .Select(idx => ParseEmbedding(embeddingMatrix, idx, encodingFormat))
+                    .ToArray();
+                var usage = usageParam != null ?
+                    (prediction.results![usageParamIdx]! as JObject)!.ToObject<CreateEmbeddingResponse.UsageInfo>() :
+                    default;
+                var response = new CreateEmbeddingResponse {
+                    Object = "list",
+                    Model = model,
+                    Data = embeddings,
+                    Usage = usage
+                };
+                // Return
+                return response;
+            };
+            // Return
+            return result;
+        }
+
+        private Task<Prediction> CreatePrediction(
+            string tag,
+            Dictionary<string, object?> inputs,
+            object acceleration
+        ) => acceleration switch {
+            Acceleration acc => predictions.Create(tag, inputs, acc),
+            RemoteAcceleration acc => remotePredictions.Create(tag, inputs, acc),
+            _ => throw new InvalidOperationException($"Cannot create {tag} prediction because acceleration is invalid: {acceleration}")
+        };
+
+        private unsafe Embedding ParseEmbedding(
+            Tensor<float> matrix,
+            int index,
+            EncodingFormat format
+        ) {
+            fixed (float* data = matrix) {
+                var baseAddress = data + index * matrix.shape[1];
+                var floatSpan = new ReadOnlySpan<float>(baseAddress, matrix.shape[1]);
+                var byteSpan = new ReadOnlySpan<byte>(baseAddress, matrix.shape[1] * sizeof(float));
+                var embeddingVector = format == EncodingFormat.Float ? floatSpan.ToArray() : null;
+                var base64Rep = format == EncodingFormat.Base64 ? Convert.ToBase64String(byteSpan) : null;
+                var embedding = new Embedding {
+                    Object = @"embedding",
+                    Floats = embeddingVector,
+                    Index = index,
+                    Base64 = base64Rep
+                };
+                return embedding;
+            }
+        }
+        #endregion
+    }
+}

package/Runtime/Beta/OpenAI/EmbeddingService.cs.meta

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

package/Runtime/Beta/OpenAI/OpenAIClient.cs

@@ -0,0 +1,50 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Beta.OpenAI {
+
+    using Services;
+    using PredictorService = global::Muna.Services.PredictorService;
+    using EdgePredictionService = global::Muna.Services.PredictionService;
+
+    /// <summary>
+    /// Mock OpenAI client.
+    /// </summary>
+    public sealed class OpenAIClient {
+
+        #region --Client API--
+        /// <summary>
+        /// Create chat conversations.
+        /// </summary>
+        public readonly ChatService Chat;
+
+        /// <summary>
+        /// Create embedding vectors.
+        /// </summary>
+        public readonly EmbeddingService Embeddings;
+
+        /// <summary>
+        /// Create speech and transcriptions.
+        /// </summary>
+        public readonly AudioService Audio;
+        #endregion
+
+
+        #region --Operations--
+
+        internal OpenAIClient(
+            PredictorService predictors,
+            EdgePredictionService predictions,
+            RemotePredictionService remotePredictions
+        ) {
+            Chat = new ChatService(predictors, predictions, remotePredictions);
+            Embeddings = new EmbeddingService(predictors, predictions, remotePredictions);
+            Audio = new AudioService(predictors, predictions, remotePredictions);
+        }
+        #endregion
+    }
+}

package/Runtime/Beta/OpenAI/OpenAIClient.cs.meta

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