Skip to content

armgit / uzu

Public Imported from GitHub
0

A high-performance inference engine for AI models

Slop wasm legacy high level crates (#1035)

uuuvn8a63a908548e
diff --git a/Cargo.lock b/Cargo.lock
index 4477b9acc..a9de48612 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -722,6 +722,7 @@ name = "bindings-types"
version = "0.6.13"
dependencies = [
"inventory",
+ "js-sys",
"napi",
"napi-build",
"napi-derive",
@@ -4964,6 +4965,7 @@ dependencies = [
"indexmap 2.14.2",
"inventory",
"keisoku",
+ "kiban",
"nagare-macros",
"napi",
"napi-build",
@@ -10007,6 +10009,7 @@ dependencies = [
"fancy-regex 0.19.2",
"futures",
"futures-util",
+ "getrandom 0.4.3",
"hanashi",
"indexmap 2.14.2",
"indicatif",
@@ -10050,6 +10053,7 @@ dependencies = [
"uzu-engine",
"wasm-bindgen",
"wasm-bindgen-futures",
+ "web-sys",
"wiremock",
]
diff --git a/Cargo.toml b/Cargo.toml
index 7c6d1ec06..db200ee1d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -97,6 +97,7 @@ minijinja-contrib = { version = "3.0.1", features = ["pycompat"] }
clap = { version = "4.6.7", features = ["derive"] }
rand = "0.10.3"
rand_distr = "0.6.0"
+getrandom = "0.4"
sysinfo = { version = "0.39.6", default-features = false, features = ["system"] }
itertools = "0.15.0"
schemars = { version = "1.2.3", features = ["derive", "preserve_order"] }
@@ -210,6 +211,7 @@ rodio = { version = "0.23.0", default-features = false, features = [
"wav",
] }
web-sys = "0.3.106"
+js-sys = "0.3"
web-time = "1.1.0"
tauri = "2.12.4"
tauri-build = "2.7.3"
diff --git a/apps/mirai-gui/desktop/src/analytics.rs b/apps/mirai-gui/desktop/src/analytics.rs
index b4aaa8f4f..254bc8708 100644
--- a/apps/mirai-gui/desktop/src/analytics.rs
+++ b/apps/mirai-gui/desktop/src/analytics.rs
@@ -64,7 +64,7 @@ impl From<ChatReplyStats> for Stats {
struct DeviceInfo {
os_name: Option<String>,
cpu_name: Option<String>,
- memory_total: i64,
+ memory_total: Option<i64>,
}
#[derive(Serialize)]
@@ -259,7 +259,7 @@ mod tests {
device: DeviceInfo {
os_name: Some("macOS".into()),
cpu_name: Some("Apple".into()),
- memory_total: 64,
+ memory_total: Some(64),
},
};
let record = Record {
diff --git a/crates/legacy/bindings-types/Cargo.toml b/crates/legacy/bindings-types/Cargo.toml
index 5a1577149..17435f026 100644
--- a/crates/legacy/bindings-types/Cargo.toml
+++ b/crates/legacy/bindings-types/Cargo.toml
@@ -29,6 +29,7 @@ bindings-pyo3 = [
"dep:inventory",
]
bindings-wasm = [
+ "dep:js-sys",
"dep:wasm-bindgen",
"dep:serde-wasm-bindgen",
"dep:wasm-bindgen-futures",
@@ -36,6 +37,7 @@ bindings-wasm = [
]
[dependencies]
+js-sys = { workspace = true, optional = true }
uniffi = { workspace = true, optional = true }
napi = { workspace = true, optional = true }
napi-derive = { workspace = true, optional = true }
diff --git a/crates/legacy/bindings-types/src/lib.rs b/crates/legacy/bindings-types/src/lib.rs
index 5f85429af..6e129a9a1 100644
--- a/crates/legacy/bindings-types/src/lib.rs
+++ b/crates/legacy/bindings-types/src/lib.rs
@@ -8,3 +8,5 @@ pub struct PyClassRegistration {
#[cfg(feature = "bindings-pyo3")]
::inventory::collect!(PyClassRegistration);
+#[cfg(feature = "bindings-wasm")]
+pub use js_sys;
diff --git a/crates/legacy/bindings/src/backends/wasm.rs b/crates/legacy/bindings/src/backends/wasm.rs
index 94d35f497..d9d642dd2 100644
--- a/crates/legacy/bindings/src/backends/wasm.rs
+++ b/crates/legacy/bindings/src/backends/wasm.rs
@@ -1,10 +1,13 @@
+use heck::ToLowerCamelCase;
use proc_macro2::TokenStream;
-use quote::quote;
+use quote::{format_ident, quote};
use crate::{
backends::Backend,
- contexts::{ClassContext, EnumerationContext, ErrorContext, ImplementationContext, StructureContext},
- types::StructureFlavor,
+ contexts::{
+ ClassContext, EnumerationContext, ErrorContext, ImplementationContext, MethodMetadata, StructureContext,
+ },
+ types::{MethodFlavor, StructureFlavor},
};
pub struct Wasm;
@@ -17,7 +20,7 @@ impl Backend for Wasm {
#[cfg_attr(feature = "bindings-wasm", tsify(into_wasm_abi, from_wasm_abi))]
},
StructureFlavor::Class => quote! {
- #[cfg_attr(feature = "bindings-wasm", wasm_bindgen::prelude::wasm_bindgen)]
+ #[cfg_attr(feature = "bindings-wasm", wasm_bindgen::prelude::wasm_bindgen(getter_with_clone))]
},
}
}
@@ -52,4 +55,123 @@ impl Backend for Wasm {
}
}
}
+
+ fn method_attributes(metadata: &MethodMetadata) -> TokenStream {
+ if returns_map(metadata) {
+ return quote! { #[cfg(not(feature = "bindings-wasm"))] };
+ }
+ let name = metadata.method.sig.ident.to_string().to_lower_camel_case();
+ let getter = matches!(metadata.flavor, MethodFlavor::Getter).then(|| quote! { getter, });
+ quote! {
+ #[cfg_attr(feature = "bindings-wasm", wasm_bindgen::prelude::wasm_bindgen(#getter js_name = #name))]
+ }
+ }
+
+ fn method_companions(
+ context: &ImplementationContext,
+ metadata: &MethodMetadata,
+ ) -> TokenStream {
+ if matches!(metadata.flavor, MethodFlavor::FactoryWithCallback) {
+ return callback_factory(&context.self_type, metadata);
+ }
+ if returns_map(metadata) {
+ return map_method(&context.self_type, metadata);
+ }
+ if !matches!(metadata.flavor, MethodFlavor::Factory) {
+ return quote! {};
+ }
+ let self_type = &context.self_type;
+ let method_name = &metadata.method.sig.ident;
+ let mut method = metadata.method.clone();
+ method.sig.ident = format_ident!("__wasm_{}", method_name);
+ let args = metadata.arg_idents();
+ let await_call = metadata.is_async().then(|| quote! { .await });
+ method.block = syn::parse_quote! { { Self::#method_name(#(#args),*) #await_call } };
+ let attributes = Self::method_attributes(metadata);
+ quote! {
+ #[cfg(feature = "bindings-wasm")]
+ #[wasm_bindgen::prelude::wasm_bindgen]
+ impl #self_type {
+ #attributes
+ #method
+ }
+ }
+ }
+}
+
+fn returns_map(metadata: &MethodMetadata) -> bool {
+ let syn::ReturnType::Type(_, ty) = &metadata.method.sig.output else {
+ return false;
+ };
+ let syn::Type::Path(path) = ty.as_ref() else {
+ return false;
+ };
+ path.path.segments.last().is_some_and(|segment| segment.ident == "HashMap")
+}
+
+fn map_method(
+ self_type: &syn::Type,
+ metadata: &MethodMetadata,
+) -> TokenStream {
+ let mut original = metadata.method.clone();
+ original.attrs.clear();
+ let name = &original.sig.ident;
+ let js_name = name.to_string().to_lower_camel_case();
+ let getter = matches!(metadata.flavor, MethodFlavor::Getter).then(|| quote! { getter, });
+ let args = metadata.arg_idents();
+ let await_call = metadata.is_async().then(|| quote! { .await });
+ let call = if metadata.receiver().is_some() {
+ quote! { self.#name(#(#args),*) }
+ } else {
+ quote! { Self::#name(#(#args),*) }
+ };
+ let mut wrapper = original.clone();
+ wrapper.sig.ident = format_ident!("__wasm_{}", name);
+ wrapper.sig.output = syn::parse_quote! { -> bindings_types::js_sys::Map };
+ wrapper.block = syn::parse_quote! {{
+ let entries = #call #await_call;
+ let map = bindings_types::js_sys::Map::new();
+ for (key, value) in entries {
+ map.set(&wasm_bindgen::JsValue::from(key), &wasm_bindgen::JsValue::from(value));
+ }
+ map
+ }};
+ quote! {
+ #[cfg(feature = "bindings-wasm")]
+ impl #self_type { #original }
+ #[cfg(feature = "bindings-wasm")]
+ #[wasm_bindgen::prelude::wasm_bindgen]
+ impl #self_type {
+ #[wasm_bindgen::prelude::wasm_bindgen(#getter js_name = #js_name)]
+ #wrapper
+ }
+ }
+}
+
+fn callback_factory(
+ self_type: &syn::Type,
+ metadata: &MethodMetadata,
+) -> TokenStream {
+ let Some(inputs) = metadata.callback_inputs() else {
+ return syn::Error::new_spanned(&metadata.method.sig, "expected a boxed void callback").to_compile_error();
+ };
+ let args: Vec<_> = (0..inputs.len()).map(|index| format_ident!("arg{index}")).collect();
+ let name = &metadata.method.sig.ident;
+ let js_name = name.to_string().to_lower_camel_case();
+ let body = &metadata.method.block;
+ quote! {
+ #[cfg(feature = "bindings-wasm")]
+ #[wasm_bindgen::prelude::wasm_bindgen]
+ impl #self_type {
+ #[wasm_bindgen::prelude::wasm_bindgen(js_name = #js_name)]
+ pub fn #name(callback: bindings_types::js_sys::Function) -> Self {
+ let callback: Box<dyn Fn(#(#inputs),*) + Send + Sync> = Box::new(move |#(#args: #inputs),*| {
+ let arguments = bindings_types::js_sys::Array::new();
+ #(arguments.push(&wasm_bindgen::JsValue::from(#args));)*
+ let _ = callback.apply(&wasm_bindgen::JsValue::UNDEFINED, &arguments);
+ });
+ #body
+ }
+ }
+ }
}
diff --git a/crates/legacy/download-manager/src/backends/universal/universal_stream.rs b/crates/legacy/download-manager/src/backends/universal/universal_stream.rs
index d334a4dc6..cc69d0db4 100644
--- a/crates/legacy/download-manager/src/backends/universal/universal_stream.rs
+++ b/crates/legacy/download-manager/src/backends/universal/universal_stream.rs
@@ -141,35 +141,40 @@ impl UniversalStream {
let mut downloaded_bytes = resume_from;
let mut last_progress = Instant::now().checked_sub(PROGRESS_INTERVAL).unwrap_or_else(Instant::now);
let mut body = response.bytes_stream();
- loop {
- let chunk = tokio::select! {
- _ = Self::paused(&mut self.pause) => {
- file.flush().await?;
+ let result = async {
+ loop {
+ let chunk = tokio::select! {
+ _ = Self::paused(&mut self.pause) => {
+ return Ok(true);
+ },
+ chunk = body.next() => chunk,
+ };
+ let Some(chunk) = chunk else {
+ break;
+ };
+ let chunk = chunk?;
+ downloaded_bytes += chunk.len() as u64;
+ if let Some(expected_bytes) = config.expected_bytes
+ && downloaded_bytes > expected_bytes
+ {
+ return Err(UniversalBackendError::Protocol(format!(
+ "response exceeded the declared size of {expected_bytes} bytes"
+ )));
+ }
+ file.write_all(&chunk).await?;
+ if last_progress.elapsed() >= PROGRESS_INTERVAL {
self.events.send_progress(self.generation, downloaded_bytes, total_bytes);
- return Ok(true);
- },
- chunk = body.next() => chunk,
- };
- let Some(chunk) = chunk else {
- break;
- };
- let chunk = chunk?;
- downloaded_bytes += chunk.len() as u64;
- if let Some(expected_bytes) = config.expected_bytes
- && downloaded_bytes > expected_bytes
- {
- return Err(UniversalBackendError::Protocol(format!(
- "response exceeded the declared size of {expected_bytes} bytes"
- )));
- }
- file.write_all(&chunk).await?;
- if last_progress.elapsed() >= PROGRESS_INTERVAL {
- self.events.send_progress(self.generation, downloaded_bytes, total_bytes);
- last_progress = Instant::now();
+ last_progress = Instant::now();
+ }
}
+ Ok::<_, UniversalBackendError>(false)
}
+ .await;
file.flush().await?;
self.events.send_progress(self.generation, downloaded_bytes, total_bytes);
+ if result? {
+ return Ok(true);
+ }
fs::asyn::rename(artifact, &config.destination).await?;
Ok(false)
}
diff --git a/crates/legacy/download-manager/src/locks/destination_lock.rs b/crates/legacy/download-manager/src/locks/destination_lock.rs
index 0a55cb443..e5d7191df 100644
--- a/crates/legacy/download-manager/src/locks/destination_lock.rs
+++ b/crates/legacy/download-manager/src/locks/destination_lock.rs
@@ -6,6 +6,7 @@ use uuid::Uuid;
use crate::locks::{LockError, LockOwner};
pub struct DestinationLock {
+ #[cfg(not(target_family = "wasm"))]
path: PathBuf,
_lock: FileLock,
}
@@ -27,6 +28,7 @@ impl DestinationLock {
};
lock.write(&serde_json::to_vec(owner).map_err(std::io::Error::other)?).await?;
Ok(Self {
+ #[cfg(not(target_family = "wasm"))]
path,
_lock: lock,
})
@@ -90,6 +92,7 @@ impl DestinationLock {
}
}
+#[cfg(not(target_family = "wasm"))]
impl Drop for DestinationLock {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.path);
diff --git a/crates/legacy/hanashi/Cargo.toml b/crates/legacy/hanashi/Cargo.toml
index 1fe44a539..d253c5933 100644
--- a/crates/legacy/hanashi/Cargo.toml
+++ b/crates/legacy/hanashi/Cargo.toml
@@ -12,7 +12,6 @@ license.workspace = true
shoji.workspace = true
token-stream-parser.workspace = true
tokenizers.workspace = true
-openai-harmony.workspace = true
serde.workspace = true
serde_json.workspace = true
thiserror.workspace = true
@@ -23,6 +22,9 @@ indexmap.workspace = true
tracing.workspace = true
chrono.workspace = true
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+openai-harmony.workspace = true
+
[build-dependencies]
serde_json.workspace = true
diff --git a/crates/legacy/hanashi/src/chat/config.rs b/crates/legacy/hanashi/src/chat/config.rs
index ee9a74197..842a0f4dc 100644
--- a/crates/legacy/hanashi/src/chat/config.rs
+++ b/crates/legacy/hanashi/src/chat/config.rs
@@ -4,7 +4,9 @@ use shoji::types::{
session::chat::ChatModelCapabilities,
};
-use crate::chat::{Error, hanashi::config::HanashiConfig, harmony::HarmonyConfig};
+#[cfg(not(target_family = "wasm"))]
+use crate::chat::harmony::HarmonyConfig;
+use crate::chat::{Error, hanashi::config::HanashiConfig};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
@@ -13,6 +15,7 @@ pub enum EncodingConfig {
#[serde(flatten)]
config: HanashiConfig,
},
+ #[cfg(not(target_family = "wasm"))]
Harmony {
#[serde(flatten)]
config: HarmonyConfig,
@@ -25,6 +28,7 @@ impl EncodingConfig {
EncodingConfig::Hanashi {
config,
} => config.default_reasoning_effort().map_err(Error::from),
+ #[cfg(not(target_family = "wasm"))]
EncodingConfig::Harmony {
config,
} => Ok(config.default_reasoning_effort()),
@@ -33,11 +37,12 @@ impl EncodingConfig {
pub fn select(encodings: &[Value]) -> Option<Value> {
let parse = |value: &Value| serde_json::from_str::<EncodingConfig>(&value.json).ok();
- encodings
- .iter()
- .find(|value| matches!(parse(value), Some(EncodingConfig::Harmony { .. })))
- .or_else(|| encodings.iter().find(|value| parse(value).is_some()))
- .cloned()
+ #[cfg(not(target_family = "wasm"))]
+ if let Some(value) = encodings.iter().find(|value| matches!(parse(value), Some(EncodingConfig::Harmony { .. })))
+ {
+ return Some(value.clone());
+ }
+ encodings.iter().find(|value| parse(value).is_some()).cloned()
}
pub fn capabilities(&self) -> Result<ChatModelCapabilities, Error> {
@@ -45,6 +50,7 @@ impl EncodingConfig {
EncodingConfig::Hanashi {
config,
} => config.capabilities().map_err(Error::from),
+ #[cfg(not(target_family = "wasm"))]
EncodingConfig::Harmony {
config,
} => Ok(config.capabilities()),
diff --git a/crates/legacy/hanashi/src/chat/error.rs b/crates/legacy/hanashi/src/chat/error.rs
index cc4973b85..25a831203 100644
--- a/crates/legacy/hanashi/src/chat/error.rs
+++ b/crates/legacy/hanashi/src/chat/error.rs
@@ -1,4 +1,6 @@
-use crate::chat::{hanashi::Error as HanashiError, harmony::Error as HarmonyError};
+use crate::chat::hanashi::Error as HanashiError;
+#[cfg(not(target_family = "wasm"))]
+use crate::chat::harmony::Error as HarmonyError;
#[derive(Debug, thiserror::Error)]
#[non_exhaustive]
@@ -6,5 +8,6 @@ pub enum Error {
#[error(transparent)]
Hanashi(#[from] HanashiError),
#[error(transparent)]
+ #[cfg(not(target_family = "wasm"))]
Harmony(#[from] HarmonyError),
}
diff --git a/crates/legacy/hanashi/src/chat/mod.rs b/crates/legacy/hanashi/src/chat/mod.rs
index 8ffdbd2db..774d407f1 100644
--- a/crates/legacy/hanashi/src/chat/mod.rs
+++ b/crates/legacy/hanashi/src/chat/mod.rs
@@ -2,6 +2,7 @@ mod config;
mod context;
mod error;
pub mod hanashi;
+#[cfg(not(target_family = "wasm"))]
pub mod harmony;
mod state;
@@ -12,21 +13,22 @@ pub use hanashi::renderer::strftime_now;
use shoji::types::{basic::TokenId, session::chat::ChatMessage};
pub use state::{State, SynchronizationError, SynchronizationResult};
-use crate::{
- Encoding as EncodingTrait,
- chat::{hanashi::HanashiEncodingImpl, harmony::HarmonyEncodingImpl},
-};
+#[cfg(not(target_family = "wasm"))]
+use crate::chat::harmony::HarmonyEncodingImpl;
+use crate::{Encoding as EncodingTrait, chat::hanashi::HanashiEncodingImpl};
macro_rules! dispatch {
($self:expr, $method:ident $(, $arg:expr)*) => {
match $self {
Encoding::Hanashi(inner) => inner.$method($($arg),*).map_err(Into::into),
+ #[cfg(not(target_family = "wasm"))]
Encoding::Harmony(inner) => inner.$method($($arg),*).map_err(Into::into),
}
};
(infallible $self:expr, $method:ident $(, $arg:expr)*) => {
match $self {
Encoding::Hanashi(inner) => inner.$method($($arg),*),
+ #[cfg(not(target_family = "wasm"))]
Encoding::Harmony(inner) => inner.$method($($arg),*),
}
};
@@ -34,6 +36,7 @@ macro_rules! dispatch {
pub enum Encoding {
Hanashi(HanashiEncodingImpl),
+ #[cfg(not(target_family = "wasm"))]
Harmony(HarmonyEncodingImpl),
}
@@ -44,6 +47,7 @@ impl Encoding {
) -> Result<Option<Vec<TokenId>>, Error> {
match self {
Self::Hanashi(inner) => inner.try_append(messages).map_err(Into::into),
+ #[cfg(not(target_family = "wasm"))]
Self::Harmony(_) => Ok(None),
}
}
@@ -51,6 +55,7 @@ impl Encoding {
pub fn flush(&mut self) -> Result<bool, Error> {
match self {
Self::Hanashi(inner) => inner.flush().map_err(Into::into),
+ #[cfg(not(target_family = "wasm"))]
Self::Harmony(_) => Ok(false),
}
}
diff --git a/crates/legacy/kiban/src/fs/asyn.rs b/crates/legacy/kiban/src/fs/asyn.rs
index 95b55b44a..a140a7f2c 100644
--- a/crates/legacy/kiban/src/fs/asyn.rs
+++ b/crates/legacy/kiban/src/fs/asyn.rs
@@ -6,6 +6,30 @@ use std::{
use crate::time::SystemTime;
+pub async fn canonicalize(path: impl AsRef<Path>) -> Result<PathBuf, io::Error> {
+ #[cfg(target_family = "wasm")]
+ return crate::fs::asyn_opfs::canonicalize(path.as_ref().to_str().unwrap()).await;
+
+ #[cfg(not(target_family = "wasm"))]
+ tokio::fs::canonicalize(path).await
+}
+
+pub async fn is_dir(path: impl AsRef<Path>) -> bool {
+ #[cfg(target_family = "wasm")]
+ return crate::fs::asyn_opfs::is_dir(path.as_ref().to_str().unwrap()).await;
+
+ #[cfg(not(target_family = "wasm"))]
+ tokio::fs::metadata(path).await.is_ok_and(|metadata| metadata.is_dir())
+}
+
+pub async fn is_dir_no_follow(path: impl AsRef<Path>) -> bool {
+ #[cfg(target_family = "wasm")]
+ return is_dir(path).await;
+
+ #[cfg(not(target_family = "wasm"))]
+ tokio::fs::symlink_metadata(path).await.is_ok_and(|metadata| metadata.is_dir())
+}
+
pub async fn create_dir_all(path: impl AsRef<Path>) -> Result<(), io::Error> {
#[cfg(target_family = "wasm")]
return super::asyn_opfs::dir_create_all(path.as_ref().to_str().unwrap()).await;
diff --git a/crates/legacy/kiban/src/fs/asyn_opfs.rs b/crates/legacy/kiban/src/fs/asyn_opfs.rs
index 6f2d57fad..55440e7e8 100644
--- a/crates/legacy/kiban/src/fs/asyn_opfs.rs
+++ b/crates/legacy/kiban/src/fs/asyn_opfs.rs
@@ -2,15 +2,14 @@ use std::{
io,
io::ErrorKind,
ops::RangeBounds,
- path::{Component, Path},
+ path::{Component, Path, PathBuf},
sync::OnceLock,
};
use tokio::sync::Mutex;
use web_sys::{js_sys::Reflect, wasm_bindgen::JsValue};
-use super::opfs::{self, WriteCommandType, WriteParams};
-use crate::time::SystemTime;
+use crate::{fs::opfs, time::SystemTime};
pub async fn dir_create_all(path: &str) -> Result<(), io::Error> {
let mut root = get_root_dir().await?;
@@ -21,9 +20,7 @@ pub async fn dir_create_all(path: &str) -> Result<(), io::Error> {
}
pub async fn dir_entries(path: &str) -> Result<Vec<String>, io::Error> {
- let root = get_root_dir().await?;
- let (parent, name) = resolve_parent(&root, path).await?;
- let directory = get_dir_handle(&parent, &name, false).await?;
+ let directory = get_dir_handle_root(path).await?;
let entries = directory.entries().await.map_err(|err| js_value_to_io_error(&err, ErrorKind::Other))?;
Ok(entries.into_iter().map(|(name, _)| name).collect())
}
@@ -36,6 +33,9 @@ pub async fn dir_remove_all(path: &str) -> Result<(), io::Error> {
pub async fn exists(path: &str) -> Result<bool, io::Error> {
let root = get_root_dir().await?;
+ if normalized_segments(path)?.is_empty() {
+ return Ok(true);
+ }
let (parent, name) = match resolve_parent(&root, path).await {
Ok(path) => path,
Err(err) if err.kind() == ErrorKind::NotFound => return Ok(false),
@@ -66,36 +66,12 @@ pub async fn file_copy(
}
let src_file = get_file_handle_root(src_path, false).await?;
- let total = src_file.size().await.map_err(|err| js_value_to_io_error(&err, ErrorKind::Other))?;
-
+ let contents = src_file.get_file().await.map_err(|err| js_value_to_io_error(&err, ErrorKind::Other))?;
let dst_file = get_file_handle_root(dst_path, true).await?;
let writer = dst_file.create_writable(false).await.map_err(|err| js_value_to_io_error(&err, ErrorKind::Other))?;
-
- let chunk_size = 16 * 1024;
- let mut offset = 0u64;
- while offset < total {
- let end = (offset + chunk_size).min(total);
- let chunk =
- src_file.read_range(offset..end).await.map_err(|err| js_value_to_io_error(&err, ErrorKind::Other))?;
- if chunk.is_empty() {
- break;
- }
-
- let chunk_length = chunk.len();
- let params = &WriteParams {
- command_type: WriteCommandType::Write,
- data: Some(chunk),
- position: Some(offset),
- size: None,
- };
- match writer.write_with_params(params).await {
- Ok(_) => {},
- Err(err) => {
- let _ = writer.abort().await;
- return Err(js_value_to_io_error(&err, ErrorKind::Other));
- },
- }
- offset += chunk_length as u64;
+ if let Err(err) = writer.write_blob(contents.as_blob()).await {
+ let _ = writer.abort().await;
+ return Err(js_value_to_io_error(&err, ErrorKind::Other));
}
writer.close().await.map_err(|err| js_value_to_io_error(&err, ErrorKind::Other))?;
@@ -188,6 +164,26 @@ pub async fn is_file(path: &str) -> bool {
get_file_handle_root(path, false).await.is_ok()
}
+pub async fn is_dir(path: &str) -> bool {
+ get_dir_handle_root(path).await.is_ok()
+}
+
+pub async fn canonicalize(path: &str) -> Result<PathBuf, io::Error> {
+ let normalized = Path::new("/").join(normalized_segments(path)?.join("/"));
+ if !exists(path).await? {
+ return Err(io::Error::from(ErrorKind::NotFound));
+ }
+ Ok(normalized)
+}
+
+async fn get_dir_handle_root(path: &str) -> Result<opfs::DirectoryHandle, io::Error> {
+ let mut directory = get_root_dir().await?;
+ for segment in normalized_segments(path)? {
+ directory = get_dir_handle(&directory, &segment, false).await?;
+ }
+ Ok(directory)
+}
+
pub async fn get_dir_handle(
dir: &opfs::DirectoryHandle,
path: &str,
diff --git a/crates/legacy/kiban/src/fs/opfs/file.rs b/crates/legacy/kiban/src/fs/opfs/file.rs
index 6290c1f35..5386e6c18 100644
--- a/crates/legacy/kiban/src/fs/opfs/file.rs
+++ b/crates/legacy/kiban/src/fs/opfs/file.rs
@@ -22,6 +22,10 @@ impl From<web_sys::File> for File {
}
impl File {
+ pub fn as_blob(&self) -> &Blob {
+ self.0.as_ref()
+ }
+
pub fn last_modified(&self) -> SystemTime {
SystemTime::UNIX_EPOCH + Duration::from_millis(self.0.last_modified() as u64)
}
diff --git a/crates/legacy/kiban/src/fs/opfs/writable_file_stream.rs b/crates/legacy/kiban/src/fs/opfs/writable_file_stream.rs
index 56a113ba5..2561c835c 100644
--- a/crates/legacy/kiban/src/fs/opfs/writable_file_stream.rs
+++ b/crates/legacy/kiban/src/fs/opfs/writable_file_stream.rs
@@ -43,6 +43,14 @@ impl From<FileSystemWritableFileStream> for WritableFileStream {
}
impl WritableFileStream {
+ pub async fn write_blob(
+ &self,
+ blob: &Blob,
+ ) -> Result<()> {
+ JsFuture::from(self.0.write_with_blob(blob)?).await?;
+ Ok(())
+ }
+
pub async fn write(
&self,
data: &[u8],
diff --git a/crates/legacy/kiban/src/rt/mod.rs b/crates/legacy/kiban/src/rt/mod.rs
index 7ecd018c5..09a10fdfe 100644
--- a/crates/legacy/kiban/src/rt/mod.rs
+++ b/crates/legacy/kiban/src/rt/mod.rs
@@ -1,8 +1,10 @@
+mod send_future;
#[cfg(not(target_family = "wasm"))]
mod tokio;
#[cfg(target_family = "wasm")]
mod wasm;
+pub use send_future::MakeSendFuture;
#[cfg(not(target_family = "wasm"))]
pub use tokio::TokioRuntimeHandle as RuntimeHandle;
#[cfg(target_family = "wasm")]
diff --git a/crates/legacy/kiban/src/rt/send_future.rs b/crates/legacy/kiban/src/rt/send_future.rs
new file mode 100644
index 000000000..3331d4245
--- /dev/null
+++ b/crates/legacy/kiban/src/rt/send_future.rs
@@ -0,0 +1,27 @@
+use std::{
+ pin::Pin,
+ task::{Context, Poll},
+};
+
+pub struct MakeSendFuture<F>(F);
+
+impl<F> MakeSendFuture<F> {
+ pub fn new(future: F) -> Self {
+ Self(future)
+ }
+}
+
+impl<F: Future> Future for MakeSendFuture<F> {
+ type Output = F::Output;
+
+ fn poll(
+ self: Pin<&mut Self>,
+ cx: &mut Context<'_>,
+ ) -> Poll<Self::Output> {
+ // The inner future remains pinned for the lifetime of this wrapper.
+ unsafe { self.map_unchecked_mut(|this| &mut this.0).poll(cx) }
+ }
+}
+
+#[cfg(all(target_arch = "wasm32", target_os = "unknown", not(target_feature = "atomics")))]
+unsafe impl<F> Send for MakeSendFuture<F> {}
diff --git a/crates/legacy/nagare/Cargo.toml b/crates/legacy/nagare/Cargo.toml
index 1aa2cf83d..b0148d9ba 100644
--- a/crates/legacy/nagare/Cargo.toml
+++ b/crates/legacy/nagare/Cargo.toml
@@ -53,6 +53,7 @@ bindings-wasm = [
[dependencies]
bindings-types = { workspace = true, optional = true }
bon.workspace = true
+kiban.workspace = true
bindings.workspace = true
nagare-macros.workspace = true
shoji.workspace = true
@@ -67,7 +68,7 @@ reqwest.workspace = true
futures.workspace = true
tokio-util.workspace = true
tokenizers.workspace = true
-tokio = { workspace = true, features = ["full"] }
+tokio = { workspace = true, features = ["sync", "macros", "rt"] }
uniffi = { workspace = true, optional = true }
async-trait = { workspace = true, optional = true }
napi = { workspace = true, optional = true }
@@ -82,8 +83,12 @@ wasm-bindgen-futures = { workspace = true, optional = true }
tsify = { workspace = true, optional = true }
[target.'cfg(not(target_family = "wasm"))'.dependencies]
+tokio = { workspace = true, features = ["full"] }
uuid.workspace = true
+[target.'cfg(target_family = "wasm")'.dependencies]
+uuid = { workspace = true, features = ["js"] }
+
[target.'cfg(any(target_os = "macos", target_os = "ios"))'.dependencies]
keisoku.workspace = true
diff --git a/crates/legacy/nagare/src/api/client.rs b/crates/legacy/nagare/src/api/client.rs
index 5db7643d7..42a5dc535 100644
--- a/crates/legacy/nagare/src/api/client.rs
+++ b/crates/legacy/nagare/src/api/client.rs
@@ -11,6 +11,7 @@ pub struct Client {
base_url: String,
bearer_token: Option<String>,
retry: RetryConfig,
+ timeout: Duration,
}
#[bon]
@@ -22,13 +23,14 @@ impl Client {
bearer_token: Option<String>,
#[builder(default)] retry: RetryConfig,
) -> Result<Self, Error> {
- let client = ReqwestClient::builder().timeout(timeout).build().map_err(Error::from)?;
+ let client = ReqwestClient::builder().build().map_err(Error::from)?;
Ok(Self {
client,
base_url,
bearer_token,
retry,
+ timeout,
})
}
@@ -71,7 +73,7 @@ impl Client {
&self,
path: &str,
) -> RequestBuilder {
- let request = self.client.post(format!("{}/{}", self.base_url, path));
+ let request = self.client.post(format!("{}/{}", self.base_url, path)).timeout(self.timeout);
match &self.bearer_token {
Some(token) => request.bearer_auth(token),
None => request,
diff --git a/crates/legacy/nagare/src/api/retry_config.rs b/crates/legacy/nagare/src/api/retry_config.rs
index c087ff818..c944773d4 100644
--- a/crates/legacy/nagare/src/api/retry_config.rs
+++ b/crates/legacy/nagare/src/api/retry_config.rs
@@ -1,7 +1,7 @@
use std::{future::Future, time::Duration};
+use kiban::time::{Instant, sleep};
use reqwest::{Response, header::HeaderMap};
-use tokio::time::{Instant, sleep, timeout};
use crate::api::{Error, IsTransient};
@@ -42,8 +42,9 @@ impl RetryConfig {
if remaining.is_zero() {
return Err(Error::Timeout);
}
- let Ok(result) = timeout(remaining, send_request()).await else {
- return Err(Error::Timeout);
+ let result = tokio::select! {
+ result = send_request() => result,
+ _ = sleep(remaining) => return Err(Error::Timeout),
};
let transient = match &result {
diff --git a/crates/legacy/nagare/src/chat/bindings_wasm.rs b/crates/legacy/nagare/src/chat/bindings_wasm.rs
new file mode 100644
index 000000000..eee89b5df
--- /dev/null
+++ b/crates/legacy/nagare/src/chat/bindings_wasm.rs
@@ -0,0 +1,105 @@
+use bindings_types::js_sys::{Error as JavaScriptError, Function, Promise};
+use kiban::rt::MakeSendFuture;
+use shoji::types::basic::{ToolFunction, Value};
+use uuid::Uuid;
+use wasm_bindgen::{JsCast, prelude::*};
+use wasm_bindgen_futures::JsFuture;
+
+use super::ChatSession;
+use crate::tool::func_def::{ErrorFuture, ToolDescriptor};
+
+struct JavaScriptInvocation {
+ cancel: Option<Function>,
+ identifier: String,
+}
+
+impl Drop for JavaScriptInvocation {
+ fn drop(&mut self) {
+ if let Some(cancel) = self.cancel.take() {
+ let _ = cancel.call1(&JsValue::UNDEFINED, &self.identifier.clone().into());
+ }
+ }
+}
+
+#[wasm_bindgen]
+pub struct NativeTool {
+ descriptor: ToolDescriptor,
+}
+
+#[wasm_bindgen]
+impl NativeTool {
+ /// The definition uses the serialized ToolFunction shape. The callback receives
+ /// JSON arguments and an invocation ID, and returns JSON or a promise of JSON.
+ #[wasm_bindgen(constructor)]
+ pub fn new(
+ definition_json: &str,
+ invoke_json: Function,
+ cancel: Function,
+ ) -> Result<Self, JsValue> {
+ let definition: ToolFunction =
+ serde_json::from_str(definition_json).map_err(|error| JavaScriptError::new(&error.to_string()))?;
+ let descriptor = ToolDescriptor::new(
+ definition.name,
+ definition.description,
+ definition.parameters,
+ definition.return_definition,
+ Box::new(move |arguments| {
+ Box::new(MakeSendFuture::new(call_javascript_tool(invoke_json.clone(), cancel.clone(), arguments)))
+ }),
+ );
+ Ok(Self {
+ descriptor,
+ })
+ }
+}
+
+#[wasm_bindgen]
+impl ChatSession {
+ #[wasm_bindgen(js_name = addTool)]
+ pub async fn add_tool_bindings_wasm(
+ &self,
+ tool: &NativeTool,
+ ) -> Result<(), JsValue> {
+ let mut session = self.clone();
+ session.add_tool(tool.descriptor.clone()).await.map_err(Into::into)
+ }
+
+ /// Consumes the tool handles; the session retains their callbacks.
+ #[wasm_bindgen(js_name = addTools)]
+ pub async fn add_tools_bindings_wasm(
+ &self,
+ tools: Vec<NativeTool>,
+ ) -> Result<(), JsValue> {
+ let mut session = self.clone();
+ session.add_tools(tools.into_iter().map(|tool| tool.descriptor).collect()).await.map_err(Into::into)
+ }
+}
+
+async fn call_javascript_tool(
+ invoke_json: Function,
+ cancel: Function,
+ arguments: Value,
+) -> Result<Value, ErrorFuture> {
+ let mut invocation = JavaScriptInvocation {
+ cancel: Some(cancel),
+ identifier: Uuid::new_v4().to_string(),
+ };
+ let result = async {
+ let promise =
+ invoke_json.call2(&JsValue::UNDEFINED, &arguments.json.into(), &invocation.identifier.clone().into())?;
+ JsFuture::from(Promise::resolve(&promise)).await
+ }
+ .await;
+ invocation.cancel = None;
+ let json = result.map_err(javascript_error)?.as_string().ok_or("tool result must be a JSON string")?;
+ Ok(serde_json::from_str::<serde_json::Value>(&json)?.into())
+}
+
+fn javascript_error(error: JsValue) -> ErrorFuture {
+ error
+ .dyn_ref::<JavaScriptError>()
+ .map(|error| String::from(error.message()))
+ .or_else(|| error.as_string())
+ .unwrap_or_else(|| format!("{error:?}"))
+ .into()
+}
diff --git a/crates/legacy/nagare/src/chat/chat_instance.rs b/crates/legacy/nagare/src/chat/chat_instance.rs
index a27c15f2e..7f9c11e41 100644
--- a/crates/legacy/nagare/src/chat/chat_instance.rs
+++ b/crates/legacy/nagare/src/chat/chat_instance.rs
@@ -42,7 +42,7 @@ impl ChatInstance {
}
let reference = path.unwrap_or_else(|| model.identifier.clone());
- let kind = tokio::spawn({
+ let kind_future = {
let reference = reference.clone();
async move {
if let Some(token_backend) = backend.as_chat_via_token_capable() {
@@ -55,11 +55,13 @@ impl ChatInstance {
Err(ChatSessionError::UnsupportedModel {})
}
}
- })
- .await
- .map_err(|error| ChatSessionError::Backend {
+ };
+ #[cfg(not(target_family = "wasm"))]
+ let kind = tokio::spawn(kind_future).await.map_err(|error| ChatSessionError::Backend {
message: error.to_string(),
})??;
+ #[cfg(target_family = "wasm")]
+ let kind = kind_future.await?;
Ok(Self {
kind,
diff --git a/crates/legacy/nagare/src/chat/mod.rs b/crates/legacy/nagare/src/chat/mod.rs
index af0cf4f93..d841b86f4 100644
--- a/crates/legacy/nagare/src/chat/mod.rs
+++ b/crates/legacy/nagare/src/chat/mod.rs
@@ -2,6 +2,8 @@
mod bindings_napi;
#[cfg(feature = "bindings-pyo3")]
mod bindings_pyo3;
+#[cfg(all(feature = "bindings-wasm", target_arch = "wasm32", target_os = "unknown"))]
+mod bindings_wasm;
mod chat_instance;
mod error;
pub mod message;
@@ -141,7 +143,7 @@ impl ChatSession {
pub async fn with_instance(instance: &ChatInstance) -> Result<Self, ChatSessionError> {
let model = instance.model();
- let instance = tokio::spawn({
+ let instance_future = {
let instance = instance.clone();
async move {
match instance.kind() {
@@ -153,11 +155,13 @@ impl ChatSession {
},
}
}
- })
- .await
- .map_err(|error| ChatSessionError::Backend {
+ };
+ #[cfg(not(target_family = "wasm"))]
+ let instance = tokio::spawn(instance_future).await.map_err(|error| ChatSessionError::Backend {
message: error.to_string(),
})??;
+ #[cfg(target_family = "wasm")]
+ let instance = instance_future.await?;
let supports_tool_calls = instance.supports_tool_calls();
Ok(Self {
@@ -407,6 +411,10 @@ impl ChatSession {
let tool_messages = tokio::select! {
tool_messages = self.execute_tool_calls(tool_calls) => tool_messages,
_ = cancel_token.cancelled() => break,
+ _ = sender.closed() => {
+ cancel_token.cancel();
+ break;
+ },
};
if self.try_transition(ChatSessionState::ToolCalling, ChatSessionState::Generation).await {
if tool_messages.is_empty() {
@@ -640,7 +648,7 @@ impl ChatSession {
#[cfg(feature = "bindings-pyo3")]
bindings_pyo3::spawn_with_current_task_locals(turn);
#[cfg(not(feature = "bindings-pyo3"))]
- tokio::spawn(turn);
+ kiban::rt::spawn(turn);
ChatSessionStream {
receiver: Arc::new(Mutex::new(receiver)),
cancel_token: cancel_token_to_return,
diff --git a/crates/legacy/nagare/src/chat/token.rs b/crates/legacy/nagare/src/chat/token.rs
index 47d4f458c..a78c58545 100644
--- a/crates/legacy/nagare/src/chat/token.rs
+++ b/crates/legacy/nagare/src/chat/token.rs
@@ -1,16 +1,13 @@
-use std::{
- pin::Pin,
- sync::Arc,
- time::{Duration, Instant},
-};
+use std::{pin::Pin, sync::Arc, time::Duration};
use futures::{Stream, StreamExt, stream};
use hanashi::{
Encoding as EncodingTrait,
- chat::{Encoding, EncodingConfig, TokenizerLocation, hanashi::HanashiEncodingImpl, harmony::HarmonyEncodingImpl},
+ chat::{Encoding, EncodingConfig, hanashi::HanashiEncodingImpl},
};
#[cfg(any(target_os = "macos", target_os = "ios"))]
use keisoku::KeisokuError;
+use kiban::time::Instant;
use shoji::{
traits::{
State,
@@ -61,7 +58,7 @@ impl Session {
pub async fn with_instance(
instance: Arc<dyn ChatTokenBackendInstance>,
- reference: String,
+ _reference: String,
model: &Model,
) -> Result<Self, ChatSessionError> {
let encoding_config: Option<EncodingConfig> = model
@@ -73,8 +70,9 @@ impl Session {
message: format!("Failed to parse encoding config: {error}"),
})?;
- let tokenizer_location = TokenizerLocation::Directory {
- path: reference,
+ #[cfg(not(target_family = "wasm"))]
+ let tokenizer_location = hanashi::chat::TokenizerLocation::Directory {
+ path: _reference,
name: None,
};
@@ -86,13 +84,14 @@ impl Session {
message: format!("can not create harmony encoding: {err}"),
}
}),
+ #[cfg(not(target_family = "wasm"))]
Some(EncodingConfig::Harmony {
config,
- }) => HarmonyEncodingImpl::new(config, tokenizer_location).map(Encoding::Harmony).map_err(|err| {
- ChatSessionError::Loading {
+ }) => hanashi::chat::harmony::HarmonyEncodingImpl::new(config, tokenizer_location)
+ .map(Encoding::Harmony)
+ .map_err(|err| ChatSessionError::Loading {
message: format!("can not create harmony encoding: {err}"),
- }
- }),
+ }),
None => Err(ChatSessionError::Loading {
message: "can not get encoding config".to_string(),
}),
diff --git a/crates/legacy/nagare/src/lib.rs b/crates/legacy/nagare/src/lib.rs
index bed08231a..b79c61d14 100644
--- a/crates/legacy/nagare/src/lib.rs
+++ b/crates/legacy/nagare/src/lib.rs
@@ -1,10 +1,11 @@
#[cfg(feature = "bindings-uniffi")]
uniffi::setup_scaffolding!();
-#[cfg(not(target_family = "wasm"))]
pub mod api;
pub mod chat;
+#[cfg(not(target_family = "wasm"))]
pub mod classification;
+#[cfg(not(target_family = "wasm"))]
pub mod text_to_speech;
pub mod tool;
mod util;
diff --git a/crates/legacy/nagare/src/tool/func_def.rs b/crates/legacy/nagare/src/tool/func_def.rs
index b72153848..6df87eed6 100644
--- a/crates/legacy/nagare/src/tool/func_def.rs
+++ b/crates/legacy/nagare/src/tool/func_def.rs
@@ -87,7 +87,10 @@ pub fn null_result() -> Value {
/// Runs a synchronous tool on the blocking thread pool so heavy work
/// doesn't stall the async runtime.
pub async fn run_blocking<T: Send + 'static>(func: impl FnOnce() -> T + Send + 'static) -> Result<T, ErrorFuture> {
- tokio::task::spawn_blocking(func).await.map_err(|error| -> ErrorFuture { error.into() })
+ #[cfg(not(target_family = "wasm"))]
+ return tokio::task::spawn_blocking(func).await.map_err(|error| -> ErrorFuture { error.into() });
+ #[cfg(target_family = "wasm")]
+ Ok(func())
}
fn coerce_to_schema(
diff --git a/crates/legacy/uzu/Cargo.toml b/crates/legacy/uzu/Cargo.toml
index 9c507827b..23fe8dfc5 100644
--- a/crates/legacy/uzu/Cargo.toml
+++ b/crates/legacy/uzu/Cargo.toml
@@ -83,32 +83,43 @@ serde-wasm-bindgen = { workspace = true, optional = true }
wasm-bindgen-futures = { workspace = true, optional = true }
tsify = { workspace = true, optional = true }
-[target.'cfg(not(target_family = "wasm"))'.dependencies]
-backend-remote.workspace = true
-bon.workspace = true
+[target.'cfg(not(target_os = "wasi"))'.dependencies]
nagare.workspace = true
hanashi.workspace = true
+bon.workspace = true
download-manager.workspace = true
-rodio.workspace = true
+reqwest.workspace = true
+indexmap.workspace = true
+uuid.workspace = true
+futures-util.workspace = true
+tokio = { workspace = true, features = ["sync", "macros", "rt"] }
+tokio-stream.workspace = true
serde.workspace = true
serde_json.workspace = true
thiserror.workspace = true
futures.workspace = true
-tokio = { workspace = true, features = ["full"] }
-tokio-stream = { workspace = true, features = ["full"] }
tokio-util.workspace = true
parking_lot = { workspace = true, features = ["send_guard"] }
tokenizers.workspace = true
rand.workspace = true
+tracing.workspace = true
+
+[target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
+getrandom = { workspace = true, features = ["wasm_js"] }
+uuid = { workspace = true, features = ["js"] }
+wasm-bindgen.workspace = true
+wasm-bindgen-futures.workspace = true
+web-sys = { workspace = true, features = ["Navigator", "Window"] }
+
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+backend-remote.workspace = true
+rodio.workspace = true
+tokio = { workspace = true, features = ["full"] }
+tokio-stream = { workspace = true, features = ["full"] }
dirs.workspace = true
sysinfo.workspace = true
-reqwest.workspace = true
-indexmap.workspace = true
-tracing.workspace = true
tracing-subscriber.workspace = true
tracing-appender.workspace = true
-uuid.workspace = true
-futures-util.workspace = true
async-openai.workspace = true
fancy-regex.workspace = true
@@ -121,7 +132,6 @@ tempfile.workspace = true
indicatif.workspace = true
dotenvy.workspace = true
schemars.workspace = true
-serde_json.workspace = true
mock-registry.workspace = true
rstest.workspace = true
wiremock.workspace = true
diff --git a/crates/legacy/uzu/bindings/python/uzu/__init__.pyi b/crates/legacy/uzu/bindings/python/uzu/__init__.pyi
index 15cab5f0a..84a5b2fd6 100644
--- a/crates/legacy/uzu/bindings/python/uzu/__init__.pyi
+++ b/crates/legacy/uzu/bindings/python/uzu/__init__.pyi
@@ -632,10 +632,10 @@ class Device:
@property
def cpu_name(self) -> typing.Optional[builtins.str]: ...
@property
- def memory_total(self) -> builtins.int: ...
+ def memory_total(self) -> typing.Optional[builtins.int]: ...
@property
def home_path(self) -> builtins.str: ...
- def __new__(cls, os_name: typing.Optional[builtins.str], cpu_name: typing.Optional[builtins.str], memory_total: builtins.int, home_path: builtins.str) -> Device: ...
+ def __new__(cls, os_name: typing.Optional[builtins.str], cpu_name: typing.Optional[builtins.str], memory_total: typing.Optional[builtins.int], home_path: builtins.str) -> Device: ...
@staticmethod
def create() -> Device: ...
diff --git a/crates/legacy/uzu/bindings/swift/Sources/Uzu/Generated/uzu/uzu.swift b/crates/legacy/uzu/bindings/swift/Sources/Uzu/Generated/uzu/uzu.swift
index 842eaa6b7..821b443e8 100644
--- a/crates/legacy/uzu/bindings/swift/Sources/Uzu/Generated/uzu/uzu.swift
+++ b/crates/legacy/uzu/bindings/swift/Sources/Uzu/Generated/uzu/uzu.swift
@@ -1904,12 +1904,12 @@ public func FfiConverterTypeChatModelInfo_lower(_ value: ChatModelInfo) -> RustB
public struct Device: Equatable, Hashable, Codable {
public var osName: String?
public var cpuName: String?
- public var memoryTotal: Int64
+ public var memoryTotal: Int64?
public var homePath: String
// Default memberwise initializers are never public by default, so we
// declare one manually.
- public init(osName: String?, cpuName: String?, memoryTotal: Int64, homePath: String) {
+ public init(osName: String?, cpuName: String?, memoryTotal: Int64?, homePath: String) {
self.osName = osName
self.cpuName = cpuName
self.memoryTotal = memoryTotal
@@ -1934,7 +1934,7 @@ public struct FfiConverterTypeDevice: FfiConverterRustBuffer {
try Device(
osName: FfiConverterOptionString.read(from: &buf),
cpuName: FfiConverterOptionString.read(from: &buf),
- memoryTotal: FfiConverterInt64.read(from: &buf),
+ memoryTotal: FfiConverterOptionInt64.read(from: &buf),
homePath: FfiConverterString.read(from: &buf)
)
}
@@ -1942,7 +1942,7 @@ public struct FfiConverterTypeDevice: FfiConverterRustBuffer {
public static func write(_ value: Device, into buf: inout [UInt8]) {
FfiConverterOptionString.write(value.osName, into: &buf)
FfiConverterOptionString.write(value.cpuName, into: &buf)
- FfiConverterInt64.write(value.memoryTotal, into: &buf)
+ FfiConverterOptionInt64.write(value.memoryTotal, into: &buf)
FfiConverterString.write(value.homePath, into: &buf)
}
}
@@ -2831,6 +2831,30 @@ fileprivate struct FfiConverterOptionUInt32: FfiConverterRustBuffer {
}
}
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionInt64: FfiConverterRustBuffer {
+ typealias SwiftType = Int64?
+
+ public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+ guard let value = value else {
+ writeInt(&buf, Int8(0))
+ return
+ }
+ writeInt(&buf, Int8(1))
+ FfiConverterInt64.write(value, into: &buf)
+ }
+
+ public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+ switch try readInt(&buf) as Int8 {
+ case 0: return nil
+ case 1: return try FfiConverterInt64.read(from: &buf)
+ default: throw UniffiInternalError.unexpectedOptionalTag
+ }
+ }
+}
+
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
diff --git a/crates/legacy/uzu/bindings/typescript/src/napi/index.d.mts b/crates/legacy/uzu/bindings/typescript/src/napi/index.d.mts
index 6e56c8ab8..7cab4af18 100644
--- a/crates/legacy/uzu/bindings/typescript/src/napi/index.d.mts
+++ b/crates/legacy/uzu/bindings/typescript/src/napi/index.d.mts
@@ -921,9 +921,9 @@ export declare class ChatModelInfo {
export declare class Device {
osName?: string
cpuName?: string
- memoryTotal: number
+ memoryTotal?: number
homePath: string
- constructor(osName?: string, cpuName?: string, memoryTotal: number, homePath: string)
+ constructor(osName?: string, cpuName?: string, memoryTotal?: number, homePath: string)
static create(): Device
}
diff --git a/crates/legacy/uzu/bindings/typescript/src/napi/index.d.ts b/crates/legacy/uzu/bindings/typescript/src/napi/index.d.ts
index 6e56c8ab8..7cab4af18 100644
--- a/crates/legacy/uzu/bindings/typescript/src/napi/index.d.ts
+++ b/crates/legacy/uzu/bindings/typescript/src/napi/index.d.ts
@@ -921,9 +921,9 @@ export declare class ChatModelInfo {
export declare class Device {
osName?: string
cpuName?: string
- memoryTotal: number
+ memoryTotal?: number
homePath: string
- constructor(osName?: string, cpuName?: string, memoryTotal: number, homePath: string)
+ constructor(osName?: string, cpuName?: string, memoryTotal?: number, homePath: string)
static create(): Device
}
diff --git a/crates/legacy/uzu/src/device/mod.rs b/crates/legacy/uzu/src/device/mod.rs
index 8e6c0ee57..3bf189224 100644
--- a/crates/legacy/uzu/src/device/mod.rs
+++ b/crates/legacy/uzu/src/device/mod.rs
@@ -4,6 +4,7 @@ mod os;
pub use error::DeviceError;
pub(crate) use os::home_path;
use serde::{Deserialize, Serialize};
+#[cfg(not(target_family = "wasm"))]
use sysinfo::System;
#[bindings::export(Structure(Class))]
@@ -12,11 +13,12 @@ use sysinfo::System;
pub struct Device {
pub os_name: Option<String>,
pub cpu_name: Option<String>,
- pub memory_total: i64,
+ pub memory_total: Option<i64>,
pub home_path: String,
}
impl Device {
+ #[cfg(not(target_family = "wasm"))]
pub fn new() -> Result<Self, DeviceError> {
let mut system_info = System::new_all();
system_info.refresh_all();
@@ -29,10 +31,24 @@ impl Device {
Ok(Self {
os_name,
cpu_name,
- memory_total: memory_total as i64,
+ memory_total: Some(memory_total as i64),
home_path: home_path.to_string_lossy().to_string(),
})
}
+
+ #[cfg(target_family = "wasm")]
+ pub fn new() -> Result<Self, DeviceError> {
+ let window = web_sys::window().ok_or(DeviceError::UnsupportedDevice {})?;
+ let navigator = window.navigator();
+ let memory_gib =
+ web_sys::js_sys::Reflect::get(&navigator, &"deviceMemory".into()).ok().and_then(|value| value.as_f64());
+ Ok(Self {
+ os_name: None,
+ cpu_name: None,
+ memory_total: memory_gib.map(|memory| (memory * 1024.0_f64.powi(3)) as i64),
+ home_path: home_path().unwrap().to_string_lossy().into_owned(),
+ })
+ }
}
#[bindings::export(Implementation)]
diff --git a/crates/legacy/uzu/src/device/os.rs b/crates/legacy/uzu/src/device/os.rs
index 948c30f9b..3ab3d4f7a 100644
--- a/crates/legacy/uzu/src/device/os.rs
+++ b/crates/legacy/uzu/src/device/os.rs
@@ -24,5 +24,9 @@ pub fn home_path() -> Option<PathBuf> {
let path = NSHomeDirectory();
return Some(PathBuf::from(path.to_string()));
}
- dirs::home_dir()
+ #[cfg(not(target_family = "wasm"))]
+ return dirs::home_dir();
+
+ #[cfg(target_family = "wasm")]
+ Some(PathBuf::from("/"))
}
diff --git a/crates/legacy/uzu/src/engine/error.rs b/crates/legacy/uzu/src/engine/error.rs
index 175ed4dae..3a6a3c7da 100644
--- a/crates/legacy/uzu/src/engine/error.rs
+++ b/crates/legacy/uzu/src/engine/error.rs
@@ -18,8 +18,10 @@ pub enum EngineError {
BackendNotFound {},
#[error(transparent)]
ChatSession(#[from] nagare::chat::ChatSessionError),
+ #[cfg(not(target_family = "wasm"))]
#[error(transparent)]
ClassificationSession(#[from] nagare::classification::ClassificationSessionError),
+ #[cfg(not(target_family = "wasm"))]
#[error(transparent)]
TextToSpeechSession(#[from] nagare::text_to_speech::TextToSpeechSessionError),
#[error("Unable to read model configuration: {message}")]
diff --git a/crates/legacy/uzu/src/engine/mod.rs b/crates/legacy/uzu/src/engine/mod.rs
index 492d4239d..1b2f2b292 100644
--- a/crates/legacy/uzu/src/engine/mod.rs
+++ b/crates/legacy/uzu/src/engine/mod.rs
@@ -19,6 +19,7 @@ use std::{
},
};
+#[cfg(not(target_family = "wasm"))]
use backend_remote::openai::Backend as OpenAIBackend;
pub use callback::{EngineCallback, EngineCallbackType};
pub use config::EngineConfig;
@@ -29,11 +30,9 @@ use futures_util::stream::FuturesUnordered;
use indexmap::IndexSet;
use kiban::rt::RuntimeHandle;
pub use model_info::ChatModelInfo;
-use nagare::{
- chat::{ChatInstance, ChatSession},
- classification::ClassificationSession,
- text_to_speech::TextToSpeechSession,
-};
+use nagare::chat::{ChatInstance, ChatSession};
+#[cfg(not(target_family = "wasm"))]
+use nagare::{classification::ClassificationSession, text_to_speech::TextToSpeechSession};
use shoji::{
traits::{Backend, Registry},
types::{
@@ -41,7 +40,6 @@ use shoji::{
session::chat::ChatConfig,
},
};
-use sysinfo::System;
use tokio::sync::{broadcast, oneshot, watch};
use tokio_stream::{StreamExt, wrappers::BroadcastStream};
@@ -49,16 +47,19 @@ use crate::{
device::Device,
engine::bridge::UzuLlmBackend,
helpers::SharedAccess,
- logs,
registry::{
CachedRegistry, MergedRegistry, RegistryError,
local::{Config as LocalRegistryConfig, Registry as LocalRegistry},
mirai::{Backend as MiraiBackend, HUGGING_FACE_URL, Registry as MiraiRegistry},
- openai::{Config as OpenAIConfig, Registry as OpenAIRegistry},
unique_model,
},
storage::{BearerToken, Config as StorageConfig, DownloadPhase, DownloadState, Storage},
};
+#[cfg(not(target_family = "wasm"))]
+use crate::{
+ logs,
+ registry::openai::{Config as OpenAIConfig, Registry as OpenAIRegistry},
+};
#[bindings::export(Class)]
#[derive(Clone)]
@@ -92,6 +93,7 @@ impl Engine {
huggingface_api_key.clone(),
);
let storage_cache_path = Storage::cache_path(&storage_config);
+ #[cfg(not(target_family = "wasm"))]
logs::start(storage_cache_path.clone(), &format!("{}.log", storage_config.name), false);
let storage = Arc::new(Storage::new(runtime_handle, storage_config).await?);
@@ -123,7 +125,8 @@ impl Engine {
version: uzu_backend_version.clone(),
}])
.cache_path(storage_cache_path)
- .build()?,
+ .build()
+ .await?,
);
engine.add_backend(Arc::new(uzu_backend) as Arc<dyn Backend>).await;
@@ -134,41 +137,45 @@ impl Engine {
uzu_backend_identifier.clone(),
uzu_backend_version.clone(),
local_path,
- ))?;
+ ))
+ .await?;
initializations.push(engine.start_registry(Box::new(local_registry)).await?);
}
}
- let mut openai_configs: Vec<OpenAIConfig> = vec![];
- if config.allow_ollama_usage {
- openai_configs.push(OpenAIConfig::ollama());
- }
- if config.allow_lmstudio_usage {
- openai_configs.push(OpenAIConfig::lmstudio());
- }
- if let Some(openai_api_key) = config.openai_api_key {
- openai_configs.push(OpenAIConfig::openai(openai_api_key));
- }
- if let Some(anthropic_api_key) = config.anthropic_api_key {
- openai_configs.push(OpenAIConfig::anthropic(anthropic_api_key));
- }
- if let Some(gemini_api_key) = config.gemini_api_key {
- openai_configs.push(OpenAIConfig::gemini(gemini_api_key));
- }
- if let Some(xai_api_key) = config.xai_api_key {
- openai_configs.push(OpenAIConfig::xai(xai_api_key));
- }
- if let Some(baseten_api_key) = config.baseten_api_key {
- openai_configs.push(OpenAIConfig::baseten(baseten_api_key));
- }
- if let Some(openrouter_api_key) = config.openrouter_api_key {
- openai_configs.push(OpenAIConfig::openrouter(openrouter_api_key));
- }
- for config in openai_configs {
- let registry = OpenAIRegistry::new(config.clone())?;
- let backend = OpenAIBackend::new(config.into()).map_err(|_| EngineError::UnableToCreateBackend {})?;
- initializations.push(engine.start_registry(Box::new(registry)).await?);
- engine.add_backend(Arc::new(backend) as Arc<dyn Backend>).await;
+ #[cfg(not(target_family = "wasm"))]
+ {
+ let mut openai_configs: Vec<OpenAIConfig> = vec![];
+ if config.allow_ollama_usage {
+ openai_configs.push(OpenAIConfig::ollama());
+ }
+ if config.allow_lmstudio_usage {
+ openai_configs.push(OpenAIConfig::lmstudio());
+ }
+ if let Some(openai_api_key) = config.openai_api_key {
+ openai_configs.push(OpenAIConfig::openai(openai_api_key));
+ }
+ if let Some(anthropic_api_key) = config.anthropic_api_key {
+ openai_configs.push(OpenAIConfig::anthropic(anthropic_api_key));
+ }
+ if let Some(gemini_api_key) = config.gemini_api_key {
+ openai_configs.push(OpenAIConfig::gemini(gemini_api_key));
+ }
+ if let Some(xai_api_key) = config.xai_api_key {
+ openai_configs.push(OpenAIConfig::xai(xai_api_key));
+ }
+ if let Some(baseten_api_key) = config.baseten_api_key {
+ openai_configs.push(OpenAIConfig::baseten(baseten_api_key));
+ }
+ if let Some(openrouter_api_key) = config.openrouter_api_key {
+ openai_configs.push(OpenAIConfig::openrouter(openrouter_api_key));
+ }
+ for config in openai_configs {
+ let registry = OpenAIRegistry::new(config.clone())?;
+ let backend = OpenAIBackend::new(config.into()).map_err(|_| EngineError::UnableToCreateBackend {})?;
+ initializations.push(engine.start_registry(Box::new(registry)).await?);
+ engine.add_backend(Arc::new(backend) as Arc<dyn Backend>).await;
+ }
}
let mut last_error = None;
@@ -474,7 +481,7 @@ impl Engine {
&self,
identifier: String,
) -> Result<Option<Model>, EngineError> {
- let is_directory = Path::new(&identifier).is_dir();
+ let is_directory = kiban::fs::asyn::is_dir(&identifier).await;
let matches = |model: &Model| model.identifier == identifier || model.repo_ids().contains(&identifier);
let registered = if is_directory {
unique_model(&identifier, self.models().await?.into_iter().filter(matches))?
@@ -495,9 +502,15 @@ impl Engine {
}
let models = self.models().await?;
- let mut system = System::new();
- system.refresh_memory();
- Ok(shorthand::resolve_model_shorthand(&models, &identifier, system.total_memory())?.cloned())
+ #[cfg(not(target_family = "wasm"))]
+ let memory_total = {
+ let mut system = sysinfo::System::new();
+ system.refresh_memory();
+ Some(system.total_memory())
+ };
+ #[cfg(target_family = "wasm")]
+ let memory_total = Device::new()?.memory_total.map(|memory| memory as u64);
+ Ok(shorthand::resolve_model_shorthand(&models, &identifier, memory_total)?.cloned())
}
#[bindings::export(Method)]
@@ -536,7 +549,7 @@ impl Engine {
if let Some(model) = unique_model(&path, matches.into_iter())? {
return Ok(Some(model));
}
- if Path::new(&path).is_dir() {
+ if kiban::fs::asyn::is_dir(&path).await {
let backend = UzuLlmBackend::new();
return LocalRegistry::model_at_path(Path::new(&path), backend.identifier(), backend.version())
.await
@@ -641,6 +654,7 @@ impl Engine {
Ok(session)
}
+ #[cfg(not(target_family = "wasm"))]
#[bindings::export(Method)]
pub async fn classification(
&self,
@@ -657,6 +671,7 @@ impl Engine {
}
}
+ #[cfg(not(target_family = "wasm"))]
#[bindings::export(Method)]
pub async fn text_to_speech(
&self,
diff --git a/crates/legacy/uzu/src/engine/shorthand.rs b/crates/legacy/uzu/src/engine/shorthand.rs
index 655bb8a7a..a9d3434d3 100644
--- a/crates/legacy/uzu/src/engine/shorthand.rs
+++ b/crates/legacy/uzu/src/engine/shorthand.rs
@@ -5,19 +5,24 @@ use crate::registry::RegistryError;
pub(super) fn resolve_model_shorthand<'a>(
models: &'a [Model],
requested: &str,
- memory_total: u64,
+ memory_total: Option<u64>,
) -> Result<Option<&'a Model>, RegistryError> {
let mut candidates = models.iter().filter(|model| model_shorthand_matches(model, requested)).collect::<Vec<_>>();
if candidates.is_empty() {
return Ok(None);
}
- candidates.retain(|model| checkpoint_size_bytes(model).is_some_and(|size| size <= memory_total));
+ candidates.retain(|model| {
+ checkpoint_size_bytes(model).is_some_and(|size| memory_total.is_none_or(|memory| size <= memory))
+ });
if candidates.is_empty() {
return Err(RegistryError::UnableToGetModels {
- message: format!(
- "model `{requested}` has checkpoints, but none fit in {memory_total} bytes of total memory"
- ),
+ message: match memory_total {
+ Some(memory) => {
+ format!("model `{requested}` has checkpoints, but none fit in {memory} bytes of total memory")
+ },
+ None => format!("model `{requested}` has no checkpoints with a known size"),
+ },
});
}
diff --git a/crates/legacy/uzu/src/lib.rs b/crates/legacy/uzu/src/lib.rs
index 4bde59fd7..244d6f222 100644
--- a/crates/legacy/uzu/src/lib.rs
+++ b/crates/legacy/uzu/src/lib.rs
@@ -41,21 +41,21 @@ inventory::submit! {
}
}
-#[cfg(not(target_family = "wasm"))]
+#[cfg(not(target_os = "wasi"))]
pub mod device;
-#[cfg(not(target_family = "wasm"))]
+#[cfg(not(target_os = "wasi"))]
pub mod engine;
-#[cfg(not(target_family = "wasm"))]
+#[cfg(not(target_os = "wasi"))]
pub mod helpers;
#[cfg(not(target_family = "wasm"))]
pub mod logs;
#[cfg(not(target_family = "wasm"))]
pub mod player;
-#[cfg(not(target_family = "wasm"))]
+#[cfg(not(target_os = "wasi"))]
pub mod registry;
-#[cfg(not(target_family = "wasm"))]
+#[cfg(not(target_os = "wasi"))]
pub mod storage;
-#[cfg(not(target_family = "wasm"))]
+#[cfg(not(target_os = "wasi"))]
pub use nagare as session;
-#[cfg(not(target_family = "wasm"))]
+#[cfg(not(target_os = "wasi"))]
pub use shoji::*;
diff --git a/crates/legacy/uzu/src/registry/local/mod.rs b/crates/legacy/uzu/src/registry/local/mod.rs
index def1e1d52..cfca324db 100644
--- a/crates/legacy/uzu/src/registry/local/mod.rs
+++ b/crates/legacy/uzu/src/registry/local/mod.rs
@@ -1,9 +1,10 @@
mod config;
-use std::{fs, future::Future, path::Path, pin::Pin};
+use std::{future::Future, path::Path, pin::Pin};
pub use config::Config;
use hanashi::chat::EncodingConfig;
+use kiban::{fs::asyn as fs, rt::MakeSendFuture};
use shoji::{
traits::Registry as RegistryTrait,
types::{
@@ -26,13 +27,13 @@ impl Registry {
backend_version: String,
) -> Result<Model, RegistryError> {
let registry =
- Self::new(Config::new(backend_identifier, backend_version, path.to_string_lossy().into_owned()))?;
+ Self::new(Config::new(backend_identifier, backend_version, path.to_string_lossy().into_owned())).await?;
registry.model(Path::new(&registry.config.path)).await
}
- pub fn new(mut config: Config) -> Result<Self, RegistryError> {
- config.path = Path::new(&config.path)
- .canonicalize()
+ pub async fn new(mut config: Config) -> Result<Self, RegistryError> {
+ config.path = fs::canonicalize(&config.path)
+ .await
.map_err(|error| RegistryError::UnableToGetModels {
message: format!("Unable to open local model path {}: {error}", config.path),
})?
@@ -52,26 +53,19 @@ impl RegistryTrait for Registry {
}
fn models(&self) -> Pin<Box<dyn Future<Output = Result<Vec<Model>, RegistryError>> + Send + '_>> {
- Box::pin(async {
+ Box::pin(MakeSendFuture::new(async {
let path = Path::new(&self.config.path);
- if path.join("config.json").is_file() {
+ if fs::is_file(path.join("config.json")).await {
return Ok(vec![self.model(path).await?]);
}
- let entries = fs::read_dir(path).map_err(|error| RegistryError::UnableToGetModels {
+ let entries = fs::read_dir(path).await.map_err(|error| RegistryError::UnableToGetModels {
message: error.to_string(),
})?;
let mut models = Vec::new();
- for entry in entries {
- let entry = entry.map_err(|error| RegistryError::UnableToGetModels {
- message: error.to_string(),
- })?;
- let path = entry.path();
- let file_type = entry.file_type().map_err(|error| RegistryError::UnableToGetModels {
- message: error.to_string(),
- })?;
- if !file_type.is_dir() {
+ for path in entries {
+ if !fs::is_dir_no_follow(&path).await {
continue;
}
match self.model(&path).await {
@@ -83,7 +77,7 @@ impl RegistryTrait for Registry {
}
Ok(models)
- })
+ }))
}
}
@@ -118,13 +112,13 @@ impl Registry {
path: path.to_string_lossy().to_string(),
},
},
- load_encoding(path),
+ load_encoding(path).await,
))
}
}
-fn load_encoding(model_path: &Path) -> Option<Value> {
- let Ok(text) = fs::read_to_string(model_path.join("encoding.json")) else {
+async fn load_encoding(model_path: &Path) -> Option<Value> {
+ let Ok(text) = fs::read_to_string(model_path.join("encoding.json")).await else {
return None;
};
let parsed = serde_json::from_str::<serde_json::Value>(&text);
diff --git a/crates/legacy/uzu/src/registry/mirai/fetch_models.rs b/crates/legacy/uzu/src/registry/mirai/fetch_models.rs
index aca969513..dfc5140a1 100644
--- a/crates/legacy/uzu/src/registry/mirai/fetch_models.rs
+++ b/crates/legacy/uzu/src/registry/mirai/fetch_models.rs
@@ -19,7 +19,7 @@ pub struct FetchModels {
pub struct CatalogDevice {
os_name: Option<String>,
cpu_name: Option<String>,
- memory_total: i64,
+ memory_total: Option<i64>,
}
impl From<&Device> for CatalogDevice {
@@ -50,7 +50,7 @@ mod tests {
let device = Device {
os_name: Some("macOS".to_string()),
cpu_name: Some("Apple silicon".to_string()),
- memory_total: 32_000_000_000,
+ memory_total: Some(32_000_000_000),
home_path: "/Users/private-user".to_string(),
};
let request = FetchModels::builder().device(CatalogDevice::from(&device)).backends(vec![]).build();
diff --git a/crates/legacy/uzu/src/registry/mirai/hugging_face.rs b/crates/legacy/uzu/src/registry/mirai/hugging_face.rs
index 872846901..16503b2ea 100644
--- a/crates/legacy/uzu/src/registry/mirai/hugging_face.rs
+++ b/crates/legacy/uzu/src/registry/mirai/hugging_face.rs
@@ -21,10 +21,8 @@ impl HuggingFace {
#[builder(default = HUGGING_FACE_URL.to_string(), into)] endpoint: String,
token: Option<BearerToken>,
) -> Result<Self, RegistryError> {
- let client = Client::builder().timeout(Duration::from_secs(30)).build().map_err(|error| {
- RegistryError::UnableToCreate {
- message: error.to_string(),
- }
+ let client = Client::builder().build().map_err(|error| RegistryError::UnableToCreate {
+ message: error.to_string(),
})?;
let endpoint = Url::parse(&endpoint).map_err(|error| RegistryError::UnableToCreate {
message: error.to_string(),
@@ -53,7 +51,7 @@ impl HuggingFace {
let mut metadata_url = self
.url(["api", "models"].into_iter().chain(repository.identifier.split('/')).chain(["revision", revision]))?;
metadata_url.set_query(Some("blobs=true"));
- let mut request = self.client.get(metadata_url);
+ let mut request = self.client.get(metadata_url).timeout(Duration::from_secs(30));
if let Some(token) = &self.token {
request = request.header(AUTHORIZATION, token.header_value());
}
diff --git a/crates/legacy/uzu/src/registry/mirai/registry.rs b/crates/legacy/uzu/src/registry/mirai/registry.rs
index d6c06168e..ca44867d7 100644
--- a/crates/legacy/uzu/src/registry/mirai/registry.rs
+++ b/crates/legacy/uzu/src/registry/mirai/registry.rs
@@ -1,5 +1,4 @@
use std::{
- fs::{read_to_string, remove_file, rename, write},
future::Future,
io,
path::{Path, PathBuf},
@@ -10,6 +9,10 @@ use std::{
use bon::bon;
use download_manager::BearerToken;
use futures::{StreamExt, stream};
+use kiban::{
+ fs::asyn::{read_to_string, remove_file, rename, write},
+ rt::MakeSendFuture,
+};
use nagare::api::{Client, Error as ApiError};
use shoji::{
traits::Registry as RegistryTrait,
@@ -39,7 +42,7 @@ pub struct Registry {
#[bon]
impl Registry {
#[builder]
- pub fn new(
+ pub async fn new(
api_key: Option<String>,
huggingface_api_key: Option<BearerToken>,
device: Device,
@@ -56,7 +59,7 @@ impl Registry {
})?;
let hugging_face =
HuggingFace::builder().endpoint(hugging_face_url).maybe_token(huggingface_api_key).build()?;
- let snapshot = Self::load_registry(&cache_path).ok().map(|models| (models, false));
+ let snapshot = Self::load_registry(&cache_path).await.ok().map(|models| (models, false));
Ok(Self {
device: (&device).into(),
@@ -98,7 +101,7 @@ impl RegistryTrait for Registry {
&self,
on_update: Arc<dyn Fn() + Send + Sync>,
) -> Pin<Box<dyn Future<Output = Result<(Vec<Model>, bool), RegistryError>> + Send + '_>> {
- Box::pin(async move {
+ Box::pin(MakeSendFuture::new(async move {
let cached = self.cached_listing().map(|(models, _)| models).unwrap_or_default();
if !cached.is_empty() {
self.publish((cached.clone(), false), &on_update);
@@ -107,12 +110,12 @@ impl RegistryTrait for Registry {
message: error.to_string(),
})?;
let listing = self.resolve(models, cached, &on_update).await;
- if let Err(error) = self.save_registry(&listing.0) {
+ if let Err(error) = self.save_registry(&listing.0).await {
tracing::warn!(?error, "failed to save Mirai registry");
}
self.publish(listing.clone(), &on_update);
Ok(listing)
- })
+ }))
}
}
@@ -122,7 +125,7 @@ impl Registry {
.device(self.device.clone())
.backends(self.backends.clone())
.include_traces(self.include_traces)
- .show_all(std::env::var("UZU_REGISTRY_SHOW_ALL").is_ok())
+ .show_all(cfg!(target_family = "wasm") || std::env::var("UZU_REGISTRY_SHOW_ALL").is_ok())
.build();
let response = self.client.call::<FetchModels>(&request).await?;
response.models().ok_or_else(|| ApiError::Decode("response contained no models".to_string()))
@@ -211,27 +214,29 @@ impl Registry {
Some(model)
}
- fn save_registry(
+ async fn save_registry(
&self,
models: &[Model],
) -> io::Result<()> {
let temporary = self.cache_path.join(format!(".registry-{}.json", uuid::Uuid::new_v4()));
- let saved = (|| {
+ let saved = async {
let contents = serde_json::to_vec_pretty(models).map_err(io::Error::other)?;
- write(&temporary, contents)?;
- rename(&temporary, self.cache_path.join("registry.json"))
- })();
+ write(&temporary, contents).await?;
+ rename(&temporary, self.cache_path.join("registry.json")).await
+ }
+ .await;
if saved.is_err() {
- let _ = remove_file(temporary);
+ let _ = remove_file(temporary).await;
}
saved
}
- fn load_registry(cache_path: &Path) -> Result<Vec<Model>, RegistryError> {
- let contents =
- read_to_string(cache_path.join("registry.json")).map_err(|error| RegistryError::UnableToGetModels {
+ async fn load_registry(cache_path: &Path) -> Result<Vec<Model>, RegistryError> {
+ let contents = read_to_string(cache_path.join("registry.json")).await.map_err(|error| {
+ RegistryError::UnableToGetModels {
message: format!("Unable to read registry: {}", error),
- })?;
+ }
+ })?;
serde_json::from_str(&contents).map_err(|error| RegistryError::UnableToGetModels {
message: format!("Unable to parse registry: {}", error),
})
diff --git a/crates/legacy/uzu/src/registry/mod.rs b/crates/legacy/uzu/src/registry/mod.rs
index 679586365..03212d007 100644
--- a/crates/legacy/uzu/src/registry/mod.rs
+++ b/crates/legacy/uzu/src/registry/mod.rs
@@ -3,6 +3,7 @@ mod error;
pub mod local;
mod merged;
pub mod mirai;
+#[cfg(not(target_family = "wasm"))]
pub mod openai;
pub use cached::CachedRegistry;
diff --git a/crates/legacy/uzu/src/storage/storage.rs b/crates/legacy/uzu/src/storage/storage.rs
index 374f6017c..2f498fc13 100644
--- a/crates/legacy/uzu/src/storage/storage.rs
+++ b/crates/legacy/uzu/src/storage/storage.rs
@@ -124,7 +124,7 @@ impl Storage {
keep_paths: &[PathBuf],
) {
for model_path in fs::asyn::read_dir(self.models_path()).await.unwrap_or_default() {
- if !tokio::fs::symlink_metadata(&model_path).await.is_ok_and(|metadata| metadata.is_dir()) {
+ if !fs::asyn::is_dir_no_follow(&model_path).await {
continue;
}
let candidates = if keep_paths.iter().any(|path| path.starts_with(&model_path)) {
@@ -134,7 +134,7 @@ impl Storage {
};
for path in candidates {
if keep_paths.iter().any(|keep| keep.starts_with(&path))
- || !tokio::fs::symlink_metadata(&path).await.is_ok_and(|metadata| metadata.is_dir())
+ || !fs::asyn::is_dir_no_follow(&path).await
|| DestinationLock::held_within(&path).await
{
continue;
diff --git a/crates/legacy/uzu/tests/engine/shorthand.rs b/crates/legacy/uzu/tests/engine/shorthand.rs
index d0b3692d8..1557d22d4 100644
--- a/crates/legacy/uzu/tests/engine/shorthand.rs
+++ b/crates/legacy/uzu/tests/engine/shorthand.rs
@@ -15,7 +15,7 @@ fn family_only_prefers_largest_mirai_model_that_fits() {
checkpoint("27b", 27 * GB, "mlx-community", "mlx", 4, 16 * GB),
];
- let resolved = resolve_model_shorthand(&models, "qwen3.5", 32 * GB as u64).unwrap().unwrap();
+ let resolved = resolve_model_shorthand(&models, "qwen3.5", Some(32 * GB as u64)).unwrap().unwrap();
assert_eq!(resolved.properties.as_ref().unwrap().identifier, "4b");
assert_eq!(resolved.quantization.as_ref().unwrap().method, "mirai-m");
@@ -28,7 +28,7 @@ fn family_only_uses_largest_checkpoint_when_no_mirai_model_exists() {
checkpoint("27b", 27 * GB, "mlx-community", "mlx", 4, 16 * GB),
];
- let resolved = resolve_model_shorthand(&models, "qwen3.5", 32 * GB as u64).unwrap().unwrap();
+ let resolved = resolve_model_shorthand(&models, "qwen3.5", Some(32 * GB as u64)).unwrap().unwrap();
assert_eq!(resolved.properties.as_ref().unwrap().identifier, "27b");
}
@@ -40,10 +40,10 @@ fn shorthand_prefers_mirai_m_then_mirai_s() {
let mirai_m = checkpoint("4b", 4 * GB, "mirai", "mirai-m", 4, 4 * GB);
let models = vec![mlx.clone(), mirai_s.clone(), mirai_m.clone()];
- assert_eq!(resolve_model_shorthand(&models, "qwen3.5:4b", 8 * GB as u64), Ok(Some(&mirai_m)));
+ assert_eq!(resolve_model_shorthand(&models, "qwen3.5:4b", Some(8 * GB as u64)), Ok(Some(&mirai_m)));
let models = vec![mlx, mirai_s.clone()];
- assert_eq!(resolve_model_shorthand(&models, "qwen3.5:4b", 8 * GB as u64), Ok(Some(&mirai_s)));
+ assert_eq!(resolve_model_shorthand(&models, "qwen3.5:4b", Some(8 * GB as u64)), Ok(Some(&mirai_s)));
}
#[test]
@@ -51,9 +51,9 @@ fn shorthand_infers_family_and_quantization_vendors() {
let model = checkpoint("4b", 4 * GB, "mlx-community", "mlx", 8, 4 * GB);
let models = [model.clone()];
- assert_eq!(resolve_model_shorthand(&models, "qwen3.5:4b:mlx:8", 8 * GB as u64), Ok(Some(&model)));
+ assert_eq!(resolve_model_shorthand(&models, "qwen3.5:4b:mlx:8", Some(8 * GB as u64)), Ok(Some(&model)));
assert_eq!(
- resolve_model_shorthand(&models, "alibaba:qwen3.5:4b:mlx-community:mlx:8", 8 * GB as u64),
+ resolve_model_shorthand(&models, "alibaba:qwen3.5:4b:mlx-community:mlx:8", Some(8 * GB as u64)),
Ok(Some(&model))
);
}
@@ -62,7 +62,7 @@ fn shorthand_infers_family_and_quantization_vendors() {
fn valid_shorthand_returns_insufficient_memory_when_no_checkpoint_fits() {
let models = [checkpoint("4b", 4 * GB, "mirai", "mirai-m", 4, 4 * GB)];
- let result = resolve_model_shorthand(&models, "qwen3.5:4b", GB as u64);
+ let result = resolve_model_shorthand(&models, "qwen3.5:4b", Some(GB as u64));
assert_eq!(
result,
@@ -70,13 +70,14 @@ fn valid_shorthand_returns_insufficient_memory_when_no_checkpoint_fits() {
message: format!("model `qwen3.5:4b` has checkpoints, but none fit in {GB} bytes of total memory"),
})
);
+ assert_eq!(resolve_model_shorthand(&models, "qwen3.5:4b", None), Ok(Some(&models[0])));
}
#[test]
fn unknown_shorthand_remains_unresolved() {
let models = [checkpoint("4b", 4 * GB, "mirai", "mirai-m", 4, 4 * GB)];
- assert_eq!(resolve_model_shorthand(&models, "unknown", GB as u64), Ok(None));
+ assert_eq!(resolve_model_shorthand(&models, "unknown", Some(GB as u64)), Ok(None));
}
fn checkpoint(
diff --git a/crates/legacy/uzu/tests/registry.rs b/crates/legacy/uzu/tests/registry.rs
index 56fe70e16..099b99d4f 100644
--- a/crates/legacy/uzu/tests/registry.rs
+++ b/crates/legacy/uzu/tests/registry.rs
@@ -210,7 +210,8 @@ async fn mirai_publishes_healthy_models_before_a_stalled_resolution() -> Result<
.cache_path(directory.path().to_path_buf())
.registry_url(mirai.uri())
.hugging_face_url(hugging_face.uri())
- .build()?,
+ .build()
+ .await?,
)));
assert!(registry.cached_listing().is_none());
let (updates, mut received) = tokio::sync::mpsc::unbounded_channel();
@@ -277,7 +278,8 @@ async fn mirai_serves_disk_cache_and_keeps_it_when_new_metadata_fails() -> Resul
.cache_path(directory.path().to_path_buf())
.registry_url(mirai.uri())
.hugging_face_url(hugging_face.uri())
- .build()?;
+ .build()
+ .await?;
assert_eq!(registry.models().await?, vec![previous.clone()]);
assert!(mirai.received_requests().await.unwrap().is_empty());
@@ -444,7 +446,8 @@ async fn mirai_registry_resolves_pinned_models_once() -> Result<(), Box<dyn std:
.cache_path(directory.path().to_path_buf())
.registry_url(mirai.uri())
.hugging_face_url(hugging_face.uri())
- .build()?;
+ .build()
+ .await?;
let (models, complete) = registry.refresh_listing(Arc::new(|| {})).await?;
assert!(!complete);
assert_eq!(