ai.muna.muna 0.0.42

package/README.md

@@ -0,0 +1,79 @@
+# Muna for Unity Engine
+
+![function logo](https://raw.githubusercontent.com/muna-ai/.github/main/logo_wide.png)
+
+Run AI inference in your Unity applications. In a few steps:
+
+## Installing Muna
+Add the following items to your Unity project's `Packages/manifest.json`:
+```json
+{
+  "scopedRegistries": [
+    {
+      "name": "Muna",
+      "url": "https://registry.npmjs.com",
+      "scopes": ["ai.muna"]
+    }
+  ],
+  "dependencies": {
+    "ai.muna.muna": "0.0.43"
+  }
+}
+```
+
+## Retrieving your Access Key
+Head over to [muna.ai](https://muna.ai) to create an account by logging in. Once you do, generate an access key:
+
+![generate access key](https://raw.githubusercontent.com/muna-ai/.github/main/access_key.gif)
+
+Then add it to your Unity project in `Project Settings > Muna`:
+
+![add access key to Unity](https://raw.githubusercontent.com/muna-ai/muna-unity/main/settings.gif)
+
+## Making a Prediction
+First, create a Muna client:
+```csharp
+using Muna;
+
+// 💥 Create a Muna client
+var muna = MunaUnity.Create();
+```
+
+Then make a prediction:
+```csharp
+// 🔥 Make a prediction
+var prediction = await muna.Predictions.Create(
+    tag: "@fxn/greeting",
+    inputs: new () { ["name"] = "Roberta" }
+);
+```
+
+Then use the results:
+```csharp
+// 🚀 Use the results
+Debug.Log(prediction.results[0]);
+```
+
+___
+
+## Requirements
+- Unity 2022.3+
+
+## Supported Platforms
+- Android API Level 24+
+- iOS 14+
+- macOS 12+ (Apple Silicon and Intel)
+- Windows 10+ (64-bit only)
+- WebGL:
+  - Chrome 91+
+  - Firefox 90+
+  - Safari 16.4+
+
+## Useful Links
+- [Discover predictors to use in your apps](https://muna.ai/explore).
+- [Join our Discord community](https://muna.ai/community).
+- [Check out our docs](https://docs.muna.ai).
+- Learn more about us [on our blog](https://blog.muna.ai).
+- Reach out to us at [hi@muna.ai](mailto:hi@muna.ai).
+
+Thank you very much!

package/README.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5cdc863ca2f694f4d9473efd2681eeb1
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/API/DotNetClient.cs

@@ -0,0 +1,106 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.API {
+
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Net.Http;
+    using System.Net.Http.Headers;
+    using System.Text;
+    using System.Threading.Tasks;
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// Muna API client for .NET.
+    /// </summary>
+    public sealed class DotNetClient : MunaClient {
+
+        #region --Client API--
+        /// <summary>
+        /// Create the .NET Muna API client.
+        /// </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
+        ) : base(url.TrimEnd('/'), accessKey) {
+            client = new();
+            var ua = new ProductInfoHeaderValue(@"MunaDotNet", Muna.Version);
+            client.DefaultRequestHeaders.UserAgent.Add(ua);
+        }
+
+        /// <summary>
+        /// Make a request to a REST endpoint.
+        /// </summary>
+        /// <typeparam name="T">Deserialized response type.</typeparam>
+        /// <param name="method">HTTP request method.</param>
+        /// <param name="path">Endpoint path.</param>
+        /// <param name="payload">Request body.</param>
+        /// <param name="headers">Request headers.</param>
+        /// <returns>Deserialized response.</returns>
+        public override async Task<T?> Request<T>(
+            string method,
+            string path,
+            Dictionary<string, object?>? payload = default,
+            Dictionary<string, string>? headers = default
+        ) where T : class {
+            using var message = new HttpRequestMessage(new HttpMethod(method), $"{url}{path}");       
+            if (!string.IsNullOrEmpty(accessKey))
+                message.Headers.Authorization = new AuthenticationHeaderValue(@"Bearer", accessKey);
+            if (headers != null)
+                foreach (var header in headers)
+                    message.Headers.Add(header.Key, header.Value);
+            if (payload != null) {
+                var serializationSettings = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore };
+                var payloadStr = JsonConvert.SerializeObject(payload, serializationSettings);
+                message.Content = new StringContent(payloadStr, Encoding.UTF8, @"application/json");
+            }
+            using var response = await client.SendAsync(message);
+            var responseStr = await response.Content.ReadAsStringAsync();
+            if ((int)response.StatusCode >= 400) {
+                var errorPayload = JsonConvert.DeserializeObject<ErrorResponse>(responseStr);
+                var error = errorPayload?.errors?[0]?.message ?? @"An unknown error occurred";
+                throw new MunaAPIException(error, (int)response.StatusCode);
+            }
+            return JsonConvert.DeserializeObject<T>(responseStr)!;
+        }
+
+        /// <summary>
+        /// Download a file.
+        /// </summary>
+        /// <param name="url">Data URL.</param>
+        public override Task<Stream> Download(string url) => client.GetStreamAsync(url);
+
+        /// <summary>
+        /// Upload a data stream.
+        /// </summary>
+        /// <param name="stream">Data stream.</param>
+        /// <param name="url">Upload URL.</param>
+        /// <param name="mime">MIME type.</param>
+        public override async Task Upload(
+            Stream stream,
+            string url,
+            string? mime = null
+        ) {
+            using var content = new StreamContent(stream);
+            content.Headers.ContentType = new MediaTypeHeaderValue(mime ?? @"application/octet-stream");
+            using var response = await client.PutAsync(url, content);
+            response.EnsureSuccessStatusCode();
+        }
+        #endregion
+
+
+        #region --Operations--
+        private readonly HttpClient client;
+        #endregion
+    }
+}

package/Runtime/API/DotNetClient.cs.meta

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

package/Runtime/API/MunaClient.cs

@@ -0,0 +1,96 @@
+/*
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+#pragma warning disable 8618
+
+namespace Muna.API {
+
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// Muna API client.
+    /// </summary>
+    public abstract class MunaClient {
+
+        #region --Client API--
+        /// <summary>
+        /// Muna API URL.
+        /// </summary>
+        public readonly string url;
+
+        /// <summary>
+        /// Make a request to a REST endpoint.
+        /// </summary>
+        /// <typeparam name="T">Deserialized response type.</typeparam>
+        /// <param name="method">HTTP request method.</param>
+        /// <param name="path">Endpoint path.</param>
+        /// <param name="payload">Request body.</param>
+        /// <param name="headers">Request headers.</param>
+        /// <returns>Deserialized response.</returns>
+        public abstract Task<T?> Request<T>(
+            string method,
+            string path,
+            Dictionary<string, object?>? payload = default,
+            Dictionary<string, string>? headers = default
+        ) where T : class;
+
+        /// <summary>
+        /// Download a file.
+        /// </summary>
+        /// <param name="url">URL</param>
+        public abstract Task<Stream> Download(string url);
+
+        /// <summary>
+        /// Upload a data stream.
+        /// </summary>
+        /// <param name="stream">Data stream.</param>
+        /// <param name="url">Upload URL.</param>
+        /// <param name="mime">MIME type.</param>
+        public abstract Task Upload(
+            Stream stream,
+            string url,
+            string? mime = null
+        );
+        #endregion
+
+
+        #region --Operations--
+        /// <summary>
+        /// Muna access key.
+        /// </summary>
+        protected internal readonly string? accessKey;
+
+        protected MunaClient(string url, string? accessKey) {
+            this.url = url;
+            this.accessKey = accessKey;
+        }
+        #endregion
+    }
+
+    /// <summary>
+    /// Muna API error response.
+    /// </summary>
+    [Preserve]
+    public sealed class ErrorResponse {
+        public Error[] errors;
+        public sealed class Error {
+            public string message;
+        }
+    }
+    
+    /// <summary>
+    /// Muna API exception.
+    /// </summary>
+    public sealed class MunaAPIException : Exception {
+
+        public readonly int status;
+
+        public MunaAPIException(string message, int status)  : base(message) => this.status = status;
+    }
+}

package/Runtime/API/MunaClient.cs.meta

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

package/Runtime/API.meta

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

package/Runtime/Beta/BetaClient.cs

@@ -0,0 +1,33 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Beta {
+
+    using API;
+    using Services;
+
+    /// <summary>
+    /// Client for incubating features.
+    /// </summary>
+    public sealed class BetaClient {
+
+        #region --Client API--
+        /// <summary>
+        /// Make predictions.
+        /// </summary>
+        public readonly PredictionService Predictions;
+        #endregion
+
+
+        #region --Operations--
+
+        internal BetaClient(MunaClient client) {
+            this.Predictions = new PredictionService(client);
+        }
+        #endregion
+    }
+}

package/Runtime/Beta/BetaClient.cs.meta

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

package/Runtime/Beta/PredictionService.cs

@@ -0,0 +1,32 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Beta.Services {
+
+    using API;
+
+    /// <summary>
+    /// Make predictions.
+    /// </summary>
+    public sealed class PredictionService {
+
+        #region --Client API--
+        /// <summary>
+        /// Make remote predictions.
+        /// </summary>
+        public readonly RemotePredictionService Remote;
+        #endregion
+
+
+        #region --Operations--
+
+        internal PredictionService (MunaClient client) {
+            this.Remote = new RemotePredictionService(client);
+        }
+        #endregion
+    }
+}

package/Runtime/Beta/PredictionService.cs.meta

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

package/Runtime/Beta/RemoteAcceleration.cs

@@ -0,0 +1,38 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+namespace Muna.Beta {
+
+    using System.Runtime.Serialization;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Converters;
+
+    /// <summary>
+    /// Remote acceleration.
+    /// </summary>
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum RemoteAcceleration : int {
+        /// <summary>
+        /// Automatically choose the best acceleration.
+        /// </summary>
+        [EnumMember(Value = @"remote_auto")]
+        Auto = 0,
+        /// <summary>
+        /// Predictions run on a CPU.
+        /// </summary>
+        [EnumMember(Value = @"remote_cpu")]
+        CPU = 1,
+        /// <summary>
+        /// Predictions run on an Nvidia A40 GPU.
+        /// </summary>
+        [EnumMember(Value = @"remote_a40")]
+        A40 = 2,
+        /// <summary>
+        /// Predictions run on an Nvidia A100 GPU.
+        /// </summary>
+        [EnumMember(Value = @"remote_a100")]
+        A100 = 3,
+    }
+}

package/Runtime/Beta/RemoteAcceleration.cs.meta

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

package/Runtime/Beta/RemotePredictionService.cs

@@ -0,0 +1,187 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Beta.Services {
+
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;    
+    using System.Threading.Tasks;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
+    using API;
+    using Configuration = C.Configuration;
+
+    /// <summary>
+    /// Make remote predictions.
+    /// </summary>
+    public sealed class RemotePredictionService {
+
+        #region --Client API--
+        /// <summary>
+        /// Create a prediction by invoking it on a cloud instance.
+        /// </summary>
+        /// <param name="tag">Predictor tag.</param>
+        /// <param name="inputs">Input values.</param>
+        /// <param name="acceleration">Prediction acceleration.</param>
+        /// <returns></returns>
+        public async Task<Prediction> Create(
+            string tag,
+            Dictionary<string, object?> inputs,
+            RemoteAcceleration acceleration = default
+        ) {
+            await Configuration.InitializationTask;
+            var inputMap = (await Task.WhenAll(inputs.Select(async pair => (
+                name: pair.Key,
+                value: await ToValue(pair.Value, pair.Key)
+            )))).ToDictionary(pair => pair.name, pair => pair.value);
+            var prediction = (await client.Request<RemotePrediction>(
+                method: @"POST",
+                path: $"/predictions/remote",
+                payload: new () {
+                    [@"tag"] = tag,
+                    [@"inputs"] = inputMap,
+                    [@"acceleration"] = acceleration,
+                    [@"clientId"] = Configuration.ClientId,
+                }
+            ))!;
+            return new Prediction {
+                id = prediction.id,
+                tag = prediction.tag,
+                created = prediction.created,
+                results = prediction.results != null ?await Task.WhenAll(prediction.results.Select(ToObject)) : null,
+                latency = prediction.latency,
+                error = prediction.error,
+                logs = prediction.logs,
+            };
+        }
+        #endregion
+
+
+        #region --Operations--
+        private readonly MunaClient client;
+
+        internal RemotePredictionService(MunaClient client) => this.client = client;
+
+        private async Task<Value> ToValue( // INCOMPLETE // Image
+            object? value,
+            string name,
+            int maxDataUrlSize = 4 * 1024 * 1024
+        ) => value switch {
+            null              => new Value { type = Dtype.Null },
+            float           x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Float32, shape = new int[0] },
+            double          x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Float64, shape = new int[0] },
+            sbyte           x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int8, shape = new int[0] },
+            short           x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int16, shape = new int[0] },
+            int             x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int32, shape = new int[0] },
+            long            x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int64, shape = new int[0] },
+            byte            x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint8, shape = new int[0] },
+            ushort          x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint16, shape = new int[0] },
+            uint            x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint32, shape = new int[0] },
+            ulong           x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint64, shape = new int[0] },
+            bool            x => new Value { data = await Upload(new [] { x }.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Bool, shape = new int[0] },
+            float[]         x => new Value { data = await Upload(x.ToStream(), name,  maxDataUrlSize: maxDataUrlSize), type = Dtype.Float32, shape = new [] { x.Length } },
+            double[]        x => new Value { data = await Upload(x.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Float64, shape = new [] { x.Length } },
+            sbyte[]         x => new Value { data = await Upload(x.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int8, shape = new [] { x.Length } },
+            short[]         x => new Value { data = await Upload(x.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int16, shape = new [] { x.Length } },
+            int[]           x => new Value { data = await Upload(x.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int32, shape = new [] { x.Length } },
+            long[]          x => new Value { data = await Upload(x.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int64, shape = new [] { x.Length } },
+            byte[]          x => new Value { data = await Upload(x.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint8, shape = new [] { x.Length } },
+            ushort[]        x => new Value { data = await Upload(x.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint16, shape = new [] { x.Length } },
+            uint[]          x => new Value { data = await Upload(x.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint32, shape = new [] { x.Length } },
+            ulong[]         x => new Value { data = await Upload(x.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint64, shape = new [] { x.Length } },
+            bool[]          x => new Value { data = await Upload(x.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Bool, shape = new [] { x.Length } },
+            Tensor<float>   x => new Value { data = await Upload(x.data.ToStream(),name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Float32, shape = x.shape },
+            Tensor<double>  x => new Value { data = await Upload(x.data.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Float64, shape = x.shape },
+            Tensor<sbyte>   x => new Value { data = await Upload(x.data.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int8, shape = x.shape },
+            Tensor<short>   x => new Value { data = await Upload(x.data.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int16, shape = x.shape },
+            Tensor<int>     x => new Value { data = await Upload(x.data.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int32, shape = x.shape },
+            Tensor<long>    x => new Value { data = await Upload(x.data.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Int64, shape = x.shape },
+            Tensor<byte>    x => new Value { data = await Upload(x.data.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint8, shape = x.shape },
+            Tensor<ushort>  x => new Value { data = await Upload(x.data.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint16, shape = x.shape },
+            Tensor<uint>    x => new Value { data = await Upload(x.data.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint32, shape = x.shape },
+            Tensor<ulong>   x => new Value { data = await Upload(x.data.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Uint64, shape = x.shape },
+            Tensor<bool>    x => new Value { data = await Upload(x.data.ToStream(), name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Bool, shape = x.shape },
+            string          x => new Value { data = await Upload(x.ToStream(), name, mime: @"text/plain", maxDataUrlSize: maxDataUrlSize), type = Dtype.String },
+            IList           x => new Value { data = await Upload(JsonConvert.SerializeObject(x).ToStream(), name, mime: @"application/json", maxDataUrlSize: maxDataUrlSize), type = Dtype.List },
+            IDictionary     x => new Value { data = await Upload(JsonConvert.SerializeObject(x).ToStream(), name, mime: @"application/json", maxDataUrlSize: maxDataUrlSize), type = Dtype.Dict },
+            Image           x => new Value { data = "", type = Dtype.Image },
+            Stream          x => new Value { data = await Upload(x, name, maxDataUrlSize: maxDataUrlSize), type = Dtype.Binary },
+            Enum            x => await ToValue(x.ToObject(), name, maxDataUrlSize: maxDataUrlSize),
+            _                 => 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
+            if (value.type == Dtype.Null)
+                return null;
+            using var stream = await Download(value.data!);
+            return value.type switch {
+                Dtype.Float32   => stream.ToObject<float>(value.shape!),
+                Dtype.Float64   => stream.ToObject<double>(value.shape!),
+                Dtype.Int8      => stream.ToObject<sbyte>(value.shape!),
+                Dtype.Int16     => stream.ToObject<short>(value.shape!),
+                Dtype.Int32     => stream.ToObject<int>(value.shape!),
+                Dtype.Int64     => stream.ToObject<long>(value.shape!),
+                Dtype.Uint8     => stream.ToObject<byte>(value.shape!),
+                Dtype.Uint16    => stream.ToObject<ushort>(value.shape!),
+                Dtype.Uint32    => stream.ToObject<uint>(value.shape!),
+                Dtype.Uint64    => stream.ToObject<ulong>(value.shape!),
+                Dtype.Bool      => stream.ToObject<bool>(value.shape!),
+                Dtype.String    => new StreamReader(stream).ReadToEnd(),
+                Dtype.List      => JsonConvert.DeserializeObject<JArray>(new StreamReader(stream).ReadToEnd()),
+                Dtype.Dict      => JsonConvert.DeserializeObject<JObject>(new StreamReader(stream).ReadToEnd()),
+                Dtype.Image     => default,
+                Dtype.Binary    => stream.Clone(),
+                _               => throw new InvalidOperationException($"Failed to deserialize value with type {value.type} because it is not supported"),
+            };
+        }
+
+        private async Task<string> Upload(
+            Stream stream,
+            string name,
+            string? mime = @"application/octet-stream",
+            int maxDataUrlSize = 4 * 1024 * 1024
+        ) {
+            if (stream.Length <= maxDataUrlSize) {
+                var data = Convert.ToBase64String(stream.ToArray<byte>());
+                var result = $"data:{mime};base64,{data}";
+                return result;
+            }
+            var value = await client.Request<CreateValueResponse>(
+                method: @"POST",
+                path: "/values",
+                payload: new () { [@"name"] = name }
+            );
+            await client.Upload(stream, value!.uploadUrl!, mime: mime);
+            return value.downloadUrl!;
+        }
+
+        private async Task<Stream> Download(string url) {
+            if (url.StartsWith(@"data:")) {
+                var dataIdx = url.LastIndexOf(",") + 1;
+                var b64Data = url.Substring(dataIdx);
+                var data = Convert.FromBase64String(b64Data);
+                return new MemoryStream(data, 0, data.Length, false, false);
+            }
+            return await client.Download(url);
+        }
+
+        [Preserve, Serializable]
+        private class CreateValueResponse {
+            public string? uploadUrl;
+            public string? downloadUrl;
+        }
+
+        [Preserve, Serializable]
+        private class RemotePrediction : Prediction {
+            public new Value[]? results;
+        }
+        #endregion
+    }
+}

package/Runtime/Beta/RemotePredictionService.cs.meta

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