A high-performance inference engine for AI models
telemetry
eugene7a983e8fd4db
diff --git a/Cargo.lock b/Cargo.lockindex b1471ab7a..d609b76f1 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -3890,6 +3890,7 @@ version = "0.5.4"dependencies = ["bindings","bindings-types",+ "chrono","futures","hanashi","indexmap 2.14.0",@@ -3910,6 +3911,7 @@ dependencies = ["tokio","tokio-stream","tokio-util",+ "tracing","tsify","uniffi","wasm-bindgen",diff --git a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/mxu_mma_core.h b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/mxu_mma_core.hindex 3d31a15bd..82202985f 100644--- a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/mxu_mma_core.h+++ b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/mxu_mma_core.h@@ -282,8 +282,9 @@ struct MxuMmaCore {(simdgroup_limit_n == SIMDGROUP_BLOCK_N),[&](auto aligned_n) {auto accumulator_tile = [&]() {- if constexpr (B_PROLOGUE ==- GemmBPrologueKind::FullPrecision) {+ if constexpr (+ B_PROLOGUE == GemmBPrologueKind::FullPrecision+ ) {const int aligned_k_iterations_fp =int(params->aligned_inner_iterations);return uzu::matmul::gemm_loop<@@ -328,8 +329,9 @@ struct MxuMmaCore {scales + block_col * groups_per_row + k_offset_groups;auto loader_b = [&]() {- if constexpr (B_PROLOGUE ==- GemmBPrologueKind::ScaleBiasDequant) {+ if constexpr (+ B_PROLOGUE == GemmBPrologueKind::ScaleBiasDequant+ ) {const device BT* biases_offset =biases + block_col * groups_per_row +k_offset_groups;@@ -342,9 +344,10 @@ struct MxuMmaCore {thread_context.simdgroup_index,thread_context.simd_lane_id);- } else if constexpr (B_PROLOGUE ==- GemmBPrologueKind::- ScaleZeroPointDequant) {+ } else if constexpr (+ B_PROLOGUE ==+ GemmBPrologueKind::ScaleZeroPointDequant+ ) {const int zero_point_stride_per_row =(BITS == 4) ? ((groups_per_row + 1) / 2): groups_per_row;diff --git a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/simdgroup_mma_core.h b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/simdgroup_mma_core.hindex ce4cd08b1..1ce69ed3b 100644--- a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/simdgroup_mma_core.h+++ b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemm/common/simdgroup_mma_core.h@@ -175,8 +175,10 @@ struct SimdgroupMmaCore {const thread ThreadContext& thread_context) {constexpr GemmAlignment gemm_alignment{GEMM_ALIGNMENT_RAW};- if constexpr (gemm_alignment.contains(GemmAlignment::M) &&- gemm_alignment.contains(GemmAlignment::N)) {+ if constexpr (+ gemm_alignment.contains(GemmAlignment::M) &&+ gemm_alignment.contains(GemmAlignment::N)+ ) {if (needs_epilogue) {accumulator.apply_epilogue(d, params->leading_dimension_d, 1, epilogue);}@@ -327,8 +329,9 @@ struct SimdgroupMmaCore {thread_context.simdgroup_index,thread_context.simd_lane_id);- } else if constexpr (B_PROLOGUE ==- GemmBPrologueKind::ScaleZeroPointDequant) {+ } else if constexpr (+ B_PROLOGUE == GemmBPrologueKind::ScaleZeroPointDequant+ ) {const int zero_point_stride_per_row =(BITS == 4) ? ((groups_per_row + 1) / 2) : groups_per_row;const device uint8_t* zero_points_row_start =diff --git a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/b_source.h b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/b_source.hindex a60b59081..a9fa82495 100644--- a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/b_source.h+++ b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/b_source.h@@ -111,8 +111,9 @@ struct BSource {prep.scales = scales + out_row * in_vec_size_g + g_offset;if constexpr (B_PROLOGUE == GemmBPrologueKind::ScaleBiasDequant) {prep.biases = biases + out_row * in_vec_size_g + g_offset;- } else if constexpr (B_PROLOGUE ==- GemmBPrologueKind::ScaleZeroPointDequant) {+ } else if constexpr (+ B_PROLOGUE == GemmBPrologueKind::ScaleZeroPointDequant+ ) {if (BITS == 4) {prep.zp_stride = (in_vec_size_g + 1) / 2;prep.zps = zero_points + out_row * prep.zp_stride + g_offset / 2;diff --git a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/quant_row_offsets.h b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/quant_row_offsets.hindex d3cdbd85d..0965132c0 100644--- a/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/quant_row_offsets.h+++ b/crates/backend-uzu/src/backends/metal/kernel/matmul/gemv/common/quant_row_offsets.h@@ -30,8 +30,9 @@ struct QuantRowOffsets {offset[1] = static_cast<U>(biases[group_stride]);offset[2] = static_cast<U>(biases[2 * group_stride]);offset[3] = static_cast<U>(biases[3 * group_stride]);- } else if constexpr (B_PROLOGUE ==- GemmBPrologueKind::ScaleZeroPointDequant) {+ } else if constexpr (+ B_PROLOGUE == GemmBPrologueKind::ScaleZeroPointDequant+ ) {uchar4 zp_bytes = uchar4(zps[0],zps[zp_stride],@@ -62,8 +63,9 @@ struct QuantRowOffsets {scales += groups;if constexpr (B_PROLOGUE == GemmBPrologueKind::ScaleBiasDequant) {biases += groups;- } else if constexpr (B_PROLOGUE ==- GemmBPrologueKind::ScaleZeroPointDequant) {+ } else if constexpr (+ B_PROLOGUE == GemmBPrologueKind::ScaleZeroPointDequant+ ) {constexpr uint zps_per_byte = get_pack_factor<BITS, 8>();zps += groups / zps_per_byte;}diff --git a/crates/nagare/Cargo.toml b/crates/nagare/Cargo.tomlindex 83e6634e9..3d4b871d5 100644--- a/crates/nagare/Cargo.toml+++ b/crates/nagare/Cargo.toml@@ -56,6 +56,8 @@ shoji.workspace = truehanashi.workspace = trueserde.workspace = trueserde_json.workspace = true+chrono.workspace = true+tracing.workspace = truethiserror.workspace = trueindexmap.workspace = truereqwest.workspace = truediff --git a/crates/nagare/src/api/client.rs b/crates/nagare/src/api/client.rsindex 04286dbe5..ceab74273 100644--- a/crates/nagare/src/api/client.rs+++ b/crates/nagare/src/api/client.rs@@ -28,6 +28,40 @@ impl Client {&self,endpoint: &E,) -> Result<T, Error> {+ let response = self.send_checked(endpoint).await?;+ response.json::<T>().await.map_err(|error| Error::Decode(error.to_string()))+ }++ pub async fn send<E: Endpoint>(+ &self,+ endpoint: &E,+ ) -> Result<(), Error> {+ self.send_checked(endpoint).await?;+ Ok(())+ }+}++impl Client {+ async fn send_checked<E: Endpoint>(+ &self,+ endpoint: &E,+ ) -> Result<reqwest::Response, Error> {+ let response = self.build_request(endpoint).send().await?;+ let status = response.status();+ if !status.is_success() {+ let body = response.text().await.unwrap_or_default();+ return Err(Error::Http {+ code: status.as_u16(),+ body,+ });+ }+ Ok(response)+ }++ fn build_request<E: Endpoint>(+ &self,+ endpoint: &E,+ ) -> reqwest::RequestBuilder {let url = self.url(endpoint);let method = endpoint.method();let payload = endpoint.payload(&self.config);@@ -47,21 +81,9 @@ impl Client {for (key, value) in endpoint.headers().iter() {request = request.header(key, value);}-- let response = request.send().await?;- let status = response.status();- if !status.is_success() {- let body = response.text().await.unwrap_or_default();- return Err(Error::Http {- code: status.as_u16(),- body,- });- }- response.json::<T>().await.map_err(|error| Error::Decode(error.to_string()))+ request}-}-impl Client {fn url<E: Endpoint>(&self,endpoint: &E,diff --git a/crates/nagare/src/chat/mod.rs b/crates/nagare/src/chat/mod.rsindex 9f2abeb28..aa62f297b 100644--- a/crates/nagare/src/chat/mod.rs+++ b/crates/nagare/src/chat/mod.rs@@ -21,6 +21,8 @@ use shoji::{};use tokio::sync::{Mutex, mpsc};+use crate::telemetry::{Telemetry, TelemetryEvent};+#[bindings::export(Enumeration)]#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]pub enum ChatSessionStreamChunk {@@ -80,6 +82,8 @@ pub struct ChatSession {instance: Arc<Mutex<Instance>>,state: Arc<Mutex<ChatSessionState>>,messages: Arc<Mutex<Vec<ChatMessage>>>,+ model_id: String,+ telemetry: Telemetry,}impl ChatSession {@@ -88,10 +92,12 @@ impl ChatSession {config: ChatConfig,model: Model,path: Option<String>,+ telemetry: Telemetry,) -> Result<Self, ChatSessionError> {if !model.specializations.contains(&ModelSpecialization::Chat {}) {return Err(ChatSessionError::UnsupportedModel {});}+ let model_id = model.identifier.clone();let reference = path.unwrap_or_else(|| model.identifier.clone());let instance = tokio::spawn(async move {@@ -112,6 +118,8 @@ impl ChatSession {instance: Arc::new(Mutex::new(instance)),state: Arc::new(Mutex::new(ChatSessionState::Idle)),messages: Arc::new(Mutex::new(Vec::new())),+ model_id,+ telemetry,})}}@@ -189,6 +197,8 @@ impl ChatSession {let instance = self.instance.clone();let state = self.state.clone();let messages = self.messages.clone();+ let telemetry = self.telemetry.clone();+ let model_id = self.model_id.clone();let cancel_token = cancel_token_to_return.inner().clone();tokio::spawn(async move {@@ -206,6 +216,10 @@ impl ChatSession {drop(state);}+ telemetry.report(TelemetryEvent::ModelInferenceStarted {+ model_id: model_id.clone(),+ });+let all_messages = {let mut messages = messages.lock().await;messages.extend(input);@@ -221,6 +235,7 @@ impl ChatSession {};let turn_index: u32 = 0;+ let mut errored = false;while let Some(partial_output) = stream.next().await {match partial_output {Ok(backend_output) => {@@ -246,6 +261,10 @@ impl ChatSession {}},Err(error) => {+ errored = true;+ telemetry.report(TelemetryEvent::ModelInferenceFailed {+ error: serde_json::json!({ "message": error.to_string() }),+ });let _ = sender.send(Err(error));break;},@@ -259,6 +278,13 @@ impl ChatSession {let mut state = state.lock().await;*state = ChatSessionState::Idle;}++ if !errored && let Some(last) = outputs.values().last() {+ telemetry.report(TelemetryEvent::ModelInferenceFinished {+ model_id,+ stats: last.stats.clone(),+ });+ }});ChatSessionStream {diff --git a/crates/nagare/src/lib.rs b/crates/nagare/src/lib.rsindex daefce84a..3aa2d5625 100644--- a/crates/nagare/src/lib.rs+++ b/crates/nagare/src/lib.rs@@ -4,4 +4,5 @@ uniffi::setup_scaffolding!();pub mod api;pub mod chat;pub mod classification;+pub mod telemetry;pub mod text_to_speech;diff --git a/crates/nagare/src/telemetry/endpoint.rs b/crates/nagare/src/telemetry/endpoint.rsnew file mode 100644index 000000000..b8210b971--- /dev/null+++ b/crates/nagare/src/telemetry/endpoint.rs@@ -0,0 +1,99 @@+use indexmap::IndexMap;+use reqwest::{Method, header::CONTENT_TYPE};+use serde_json::Value;++use super::record::TelemetryRecord;+use crate::api::{Config, Endpoint, Payload};++pub(super) struct TelemetryEndpoint {+ path: String,+ body: Value,+}++impl TelemetryEndpoint {+ pub(super) fn new(+ path: String,+ context: &Value,+ record: &TelemetryRecord,+ ) -> Self {+ Self {+ path,+ body: build_body(context, record),+ }+ }+}++impl Endpoint for TelemetryEndpoint {+ fn method(&self) -> Method {+ Method::POST+ }++ fn path(&self) -> String {+ self.path.clone()+ }++ fn headers(&self) -> IndexMap<String, String> {+ IndexMap::from([(CONTENT_TYPE.to_string(), "application/json".to_string())])+ }++ fn payload(+ &self,+ _: &Config,+ ) -> Payload {+ Payload {+ query: None,+ body: Some(self.body.clone()),+ }+ }+}++fn build_body(+ context: &Value,+ record: &TelemetryRecord,+) -> Value {+ let mut body = serde_json::to_value(&record.event).unwrap_or_else(|_| Value::Object(Default::default()));+ if let Value::Object(map) = &mut body {+ map.insert("event_time".to_string(), Value::String(record.event_time.clone()));+ map.insert("device".to_string(), context.clone());+ }+ body+}++#[cfg(test)]+mod tests {+ use serde_json::json;++ use super::{super::record::TelemetryRecord, build_body};+ use crate::telemetry::TelemetryEvent;++ #[test]+ fn build_body_nests_event_time_device_and_payload() {+ let device = json!({ "os_name": "macOS" });+ let record = TelemetryRecord {+ event_time: "2026-06-04T16:24:29Z".to_string(),+ event: TelemetryEvent::ModelInferenceFinished {+ model_id: "model-1".to_string(),+ stats: Default::default(),+ },+ };+ let body = build_body(&device, &record);+ assert_eq!(body["event_name"], json!("model_inference_finished"));+ assert_eq!(body["event_time"], json!("2026-06-04T16:24:29Z"));+ assert_eq!(body["device"]["os_name"], json!("macOS"));+ assert_eq!(body["payload"]["model_id"], json!("model-1"));+ assert!(body["payload"]["stats"].is_object());+ }++ #[test]+ fn build_body_wraps_failure_error() {+ let record = TelemetryRecord {+ event_time: "2026-06-04T16:24:29Z".to_string(),+ event: TelemetryEvent::ModelInferenceFailed {+ error: json!({ "message": "boom" }),+ },+ };+ let body = build_body(&json!({}), &record);+ assert_eq!(body["event_name"], json!("model_inference_failed"));+ assert_eq!(body["payload"]["error"]["message"], json!("boom"));+ }+}diff --git a/crates/nagare/src/telemetry/event.rs b/crates/nagare/src/telemetry/event.rsnew file mode 100644index 000000000..b694d1202--- /dev/null+++ b/crates/nagare/src/telemetry/event.rs@@ -0,0 +1,24 @@+use serde::{Deserialize, Serialize};+use serde_json::Value;+use shoji::types::session::chat::ChatReplyStats;++#[derive(Debug, Clone, Serialize, Deserialize)]+#[serde(tag = "event_name", content = "payload", rename_all = "snake_case")]+pub enum TelemetryEvent {+ ModelDownloadStarted {+ model_id: String,+ },+ ModelDownloadFinished {+ model_id: String,+ },+ ModelInferenceStarted {+ model_id: String,+ },+ ModelInferenceFinished {+ model_id: String,+ stats: ChatReplyStats,+ },+ ModelInferenceFailed {+ error: Value,+ },+}diff --git a/crates/nagare/src/telemetry/mod.rs b/crates/nagare/src/telemetry/mod.rsnew file mode 100644index 000000000..16a46f2c9--- /dev/null+++ b/crates/nagare/src/telemetry/mod.rs@@ -0,0 +1,10 @@+#[cfg(not(target_family = "wasm"))]+mod endpoint;+mod event;+mod record;+mod telemetry;+#[cfg(not(target_family = "wasm"))]+mod worker;++pub use event::TelemetryEvent;+pub use telemetry::Telemetry;diff --git a/crates/nagare/src/telemetry/record.rs b/crates/nagare/src/telemetry/record.rsnew file mode 100644index 000000000..c918505bb--- /dev/null+++ b/crates/nagare/src/telemetry/record.rs@@ -0,0 +1,34 @@+use super::TelemetryEvent;++pub(super) struct TelemetryRecord {+ pub(super) event_time: String,+ pub(super) event: TelemetryEvent,+}++impl TelemetryRecord {+ pub(super) fn new(event: TelemetryEvent) -> Self {+ Self {+ event_time: now_rfc3339(),+ event,+ }+ }+}++fn now_rfc3339() -> String {+ chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true)+}++#[cfg(test)]+mod tests {+ use super::TelemetryRecord;+ use crate::telemetry::TelemetryEvent;++ #[test]+ fn new_stamps_rfc3339_utc() {+ let record = TelemetryRecord::new(TelemetryEvent::ModelDownloadFinished {+ model_id: "model-1".to_string(),+ });+ assert!(record.event_time.ends_with('Z'), "expected Z suffix: {}", record.event_time);+ assert!(chrono::DateTime::parse_from_rfc3339(&record.event_time).is_ok());+ }+}diff --git a/crates/nagare/src/telemetry/telemetry.rs b/crates/nagare/src/telemetry/telemetry.rsnew file mode 100644index 000000000..5cdca68b5--- /dev/null+++ b/crates/nagare/src/telemetry/telemetry.rs@@ -0,0 +1,63 @@+use serde_json::Value;+use tokio::sync::mpsc;+#[cfg(not(target_family = "wasm"))]+use tokio::sync::mpsc::channel as TokioMpscChannel;++use super::{TelemetryEvent, record::TelemetryRecord};+#[cfg(not(target_family = "wasm"))]+use crate::api::Client;+use crate::api::Config;++#[cfg(not(target_family = "wasm"))]+const CAPACITY: usize = 256;++#[derive(Clone)]+pub struct Telemetry {+ sender: Option<mpsc::Sender<TelemetryRecord>>,+}++impl Telemetry {+ pub fn disabled() -> Self {+ Self {+ sender: None,+ }+ }++ #[cfg(not(target_family = "wasm"))]+ pub fn new(+ client_config: Config,+ path: String,+ context: Value,+ ) -> Self {+ let client = match Client::new(client_config) {+ Ok(client) => client,+ Err(error) => {+ tracing::warn!(%error, "telemetry disabled: failed to build client");+ return Self::disabled();+ },+ };+ let (sender, receiver) = TokioMpscChannel::<TelemetryRecord>(CAPACITY);+ tokio::spawn(super::worker::run(client, path, context, receiver));+ Self {+ sender: Some(sender),+ }+ }++ #[cfg(target_family = "wasm")]+ pub fn new(+ _client_config: Config,+ _path: String,+ _context: Value,+ ) -> Self {+ Self::disabled()+ }++ pub fn report(+ &self,+ event: TelemetryEvent,+ ) {+ if let Some(sender) = &self.sender {+ let _ = sender.try_send(TelemetryRecord::new(event));+ }+ }+}diff --git a/crates/nagare/src/telemetry/worker.rs b/crates/nagare/src/telemetry/worker.rsnew file mode 100644index 000000000..eb0405dd3--- /dev/null+++ b/crates/nagare/src/telemetry/worker.rs@@ -0,0 +1,99 @@+use serde_json::Value;+use tokio::sync::mpsc;++use super::{endpoint::TelemetryEndpoint, record::TelemetryRecord};+use crate::api::{Client, Error};++const MAX_RETRIES: u32 = 4;+const BASE_BACKOFF_MS: u64 = 1_000;+const MAX_BACKOFF_MS: u64 = 16_000;++pub(super) async fn run(+ client: Client,+ path: String,+ context: Value,+ mut receiver: mpsc::Receiver<TelemetryRecord>,+) {+ while let Some(record) = receiver.recv().await {+ send_with_retry(&client, &path, &context, &record).await;+ }+}++#[derive(Debug, PartialEq)]+enum Disposition {+ Retry,+ Drop,+}++async fn send_with_retry(+ client: &Client,+ path: &str,+ context: &Value,+ record: &TelemetryRecord,+) {+ let endpoint = TelemetryEndpoint::new(path.to_string(), context, record);+ let mut attempt: u32 = 0;+ loop {+ match client.send(&endpoint).await {+ Ok(()) => return,+ Err(error) => match classify(&error) {+ Disposition::Drop => {+ tracing::warn!(%error, "telemetry event dropped");+ return;+ },+ Disposition::Retry => {+ if attempt >= MAX_RETRIES {+ tracing::warn!(%error, attempts = attempt, "telemetry event dropped after retries");+ return;+ }+ tokio::time::sleep(backoff(attempt)).await;+ attempt += 1;+ },+ },+ }+ }+}++fn classify(error: &Error) -> Disposition {+ match error {+ Error::Http {+ code,+ ..+ } if *code >= 500 => Disposition::Retry,+ Error::Http {+ ..+ } => Disposition::Drop,+ Error::Timeout | Error::Network(_) => Disposition::Retry,+ Error::Decode(_) => Disposition::Drop,+ }+}++fn backoff(attempt: u32) -> std::time::Duration {+ let millis = BASE_BACKOFF_MS.saturating_mul(2u64.saturating_pow(attempt)).min(MAX_BACKOFF_MS);+ std::time::Duration::from_millis(millis)+}++#[cfg(test)]+mod tests {+ use super::{Disposition, classify};+ use crate::api::Error;++ fn http(code: u16) -> Error {+ Error::Http {+ code,+ body: String::new(),+ }+ }++ #[test]+ fn classify_400_drops_503_retries() {+ assert_eq!(classify(&http(400)), Disposition::Drop);+ assert_eq!(classify(&http(404)), Disposition::Drop);+ assert_eq!(classify(&http(503)), Disposition::Retry);+ assert_eq!(classify(&http(500)), Disposition::Retry);+ assert_eq!(classify(&http(502)), Disposition::Retry);+ assert_eq!(classify(&Error::Timeout), Disposition::Retry);+ assert_eq!(classify(&Error::Network("x".to_string())), Disposition::Retry);+ assert_eq!(classify(&Error::Decode("x".to_string())), Disposition::Drop);+ }+}diff --git a/crates/uzu/src/device/mod.rs b/crates/uzu/src/device/mod.rsindex 8e6c0ee57..3989e159d 100644--- a/crates/uzu/src/device/mod.rs+++ b/crates/uzu/src/device/mod.rs@@ -2,7 +2,7 @@ mod error;mod os;pub use error::DeviceError;-pub(crate) use os::home_path;+pub(crate) use os::{home_path, is_environment_sandboxed};use serde::{Deserialize, Serialize};use sysinfo::System;diff --git a/crates/uzu/src/device/os.rs b/crates/uzu/src/device/os.rsindex 2ffba6db8..a6217d2cc 100644--- a/crates/uzu/src/device/os.rs+++ b/crates/uzu/src/device/os.rs@@ -26,3 +26,16 @@ pub fn home_path() -> Option<PathBuf> {}dirs::home_dir()}++#[allow(unreachable_code)]+pub fn is_environment_sandboxed() -> bool {+ #[cfg(target_os = "ios")]+ {+ return true;+ }+ #[cfg(target_os = "macos")]+ {+ return std::env::var_os("APP_SANDBOX_CONTAINER_ID").is_some();+ }+ false+}diff --git a/crates/uzu/src/engine/mod.rs b/crates/uzu/src/engine/mod.rsindex f95e5790b..d2a7520ac 100644--- a/crates/uzu/src/engine/mod.rs+++ b/crates/uzu/src/engine/mod.rs@@ -4,7 +4,7 @@ mod download_manager;mod downloader;mod error;-use std::{collections::HashMap, sync::Arc};+use std::{collections::HashMap, sync::Arc, time::Duration};use backend_remote::openai::Backend as OpenAIBackend;use backend_uzu::inference::Backend as UzuBackend;@@ -13,8 +13,14 @@ pub use config::EngineConfig;pub use download_manager::DownloadManagerType;pub use downloader::{Downloader, DownloaderStream, DownloaderStreamUpdate};pub use error::EngineError;-use indexmap::IndexSet;-use nagare::{chat::ChatSession, classification::ClassificationSession, text_to_speech::TextToSpeechSession};+use indexmap::{IndexMap, IndexSet};+use nagare::{+ api::Config as ClientConfig,+ chat::ChatSession,+ classification::ClassificationSession,+ telemetry::{Telemetry, TelemetryEvent},+ text_to_speech::TextToSpeechSession,+};use shoji::{traits::{Backend, Registry},types::{@@ -50,6 +56,7 @@ pub struct Engine {storage: SharedAccess<Storage>,backends: SharedAccess<HashMap<String, Arc<dyn Backend>>>,callback: SharedAccess<Option<Arc<EngineCallback>>>,+ telemetry: SharedAccess<Telemetry>,}impl Engine {@@ -69,6 +76,22 @@ impl Engine {}let device = Device::new()?;++ let telemetry = SharedAccess::new({+ let client_config = ClientConfig::new(+ "https://sdk.trymirai.com/api/v1".to_string(),+ Duration::from_secs(10),+ IndexMap::new(),+ );+ let context = serde_json::json!({+ "os_name": device.os_name,+ "cpu_name": device.cpu_name,+ "memory_total": device.memory_total,+ "is_environment_sandboxed": crate::device::is_environment_sandboxed(),+ });+ Telemetry::new(client_config, "telemetry/events".to_string(), context)+ });+let registry = SharedAccess::new(MergedRegistry::new(vec![]));let storage_config = StorageConfig::new(device.clone(), None, "mirai".to_string()).with_download_manager_type(config.download_manager_type.into());@@ -82,6 +105,7 @@ impl Engine {registry,backends: SharedAccess::new(HashMap::new()),callback: SharedAccess::new(None),+ telemetry,};engine.spawn_storage_listener().await;@@ -460,7 +484,8 @@ impl Engine {if let Some(backend) = model.backends.first() {let backends = self.backends.lock().await;let backend = backends.get(&backend.identifier).ok_or(EngineError::BackendNotFound {})?;- let session = ChatSession::new(backend.clone(), config, model, path).await?;+ let session =+ ChatSession::new(backend.clone(), config, model, path, self.telemetry.lock().await.clone()).await?;Ok(session)} else {Err(EngineError::BackendNotFound {})@@ -525,10 +550,29 @@ impl Engine {async fn spawn_storage_listener(&self) {let mut stream = self.storage_subscribe().await;let callback = self.callback.clone();+ let telemetry = self.telemetry.lock().await.clone();tokio::spawn(async move {+ let mut last_phase: HashMap<String, DownloadPhase> = HashMap::new();while let Some(update) = stream.next().await {- if update.is_err() {+ let Ok((id, state)) = update else {continue;+ };+ let previous = last_phase.insert(id.clone(), state.phase.clone());+ let event = match (&previous, &state.phase) {+ (prev, DownloadPhase::Downloading {}) if !matches!(prev, Some(DownloadPhase::Downloading {})) => {+ Some(TelemetryEvent::ModelDownloadStarted {+ model_id: id,+ })+ },+ (Some(DownloadPhase::Downloading {}), DownloadPhase::Downloaded {}) => {+ Some(TelemetryEvent::ModelDownloadFinished {+ model_id: id,+ })+ },+ _ => None,+ };+ if let Some(event) = event {+ telemetry.report(event);}if let Some(callback) = callback.lock().await.as_ref().cloned() {callback.on_event();