π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Eliminate #[allow(clippy::too_many_arguments)]
Manav Rathiabd1d7eef3b3
diff --git a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs b/rust/apps/ensu/src-tauri/src/commands/chat_db.rsindex fbff917f65..d8fa500da7 100644--- a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs+++ b/rust/apps/ensu/src-tauri/src/commands/chat_db.rs@@ -371,21 +371,19 @@ pub async fn chat_db_insert_message_with_uuid(state: State<'_, ChatDbState>,input: ChatMessageUpsertInput,) -> Result<ChatMessageDto, ApiError> {- let message_uuid = parse_uuid(&input.message_uuid)?;- let session_uuid = parse_uuid(&input.session_uuid)?;- let parent = optional_uuid(&input.parent_message_uuid)?;- let sender = normalize_sender(&input.sender)?;- let attachments = convert_attachments(input.attachments)?;+ let message = db::Message {+ uuid: parse_uuid(&input.message_uuid)?,+ session_uuid: parse_uuid(&input.session_uuid)?,+ parent_message_uuid: optional_uuid(&input.parent_message_uuid)?,+ sender: normalize_sender(&input.sender)?+ .parse()+ .map_err(ApiError::from)?,+ text: input.text,+ attachments: convert_attachments(input.attachments)?,+ created_at: input.created_at,+ };with_chat_db_async(&state, move |db| {- Ok(ChatMessageDto::from(db.insert_message_with_uuid(- message_uuid,- session_uuid,- sender,- &input.text,- parent,- attachments,- input.created_at,- )?))+ Ok(ChatMessageDto::from(db.insert_message_with_uuid(&message)?))}).await}diff --git a/rust/apps/ensu/src-tauri/src/commands/chat_db_migration.rs b/rust/apps/ensu/src-tauri/src/commands/chat_db_migration.rsindex 43d5cb805c..bdf7b74978 100644--- a/rust/apps/ensu/src-tauri/src/commands/chat_db_migration.rs+++ b/rust/apps/ensu/src-tauri/src/commands/chat_db_migration.rs@@ -100,15 +100,7 @@ fn import(.map_err(ApiError::from)?;for message in source.get_messages(session.uuid).map_err(ApiError::from)? {target- .insert_message_with_uuid(- message.uuid,- message.session_uuid,- message.sender.as_str(),- &message.text,- message.parent_message_uuid,- message.attachments.clone(),- message.created_at,- )+ .insert_message_with_uuid(&message).map_err(ApiError::from)?;for attachment in message.attachments {let from = source_attachments.join(&attachment.id);diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rsindex 987b59b042..1c4b257a81 100644--- a/rust/bindings/wasm/space/src/space.rs+++ b/rust/bindings/wasm/space/src/space.rs@@ -104,6 +104,15 @@ struct OpenSpaceLinkCtxJsInput {client_version: Option<String>,}+#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct PostPhotoAssetOptionsJsInput {+ width: Option<i32>,+ height: Option<i32>,+ media_type: Option<String>,+ thumb_hash: Option<String>,+}+#[derive(Serialize)]#[serde(rename_all = "camelCase")]struct CreatedSpaceJs {@@ -982,18 +991,15 @@ impl SpaceAccountCtxHandle {}/// Create a single-photo post with optional caption.- #[allow(clippy::too_many_arguments)]#[wasm_bindgen(js_name = createPhotoPost)]pub async fn create_photo_post(&self,space_id: String,photo_bytes: Vec<u8>,caption: Option<String>,- width: Option<i32>,- height: Option<i32>,- media_type: Option<String>,- thumb_hash: Option<String>,+ photo_options: JsValue,) -> Result<JsValue, WasmSpaceError> {+ let photo_options: PostPhotoAssetOptionsJsInput = swb::from_value(photo_options)?;let post_key = self.inner.generate_post_key();let object = self.inner@@ -1002,10 +1008,10 @@ impl SpaceAccountCtxHandle {&post_key,&photo_bytes,PostPhotoAssetOptions {- width,- height,- media_type,- thumb_hash,+ width: photo_options.width,+ height: photo_options.height,+ media_type: photo_options.media_type,+ thumb_hash: photo_options.thumb_hash,},).await?;diff --git a/rust/crates/assets/src/download.rs b/rust/crates/assets/src/download.rsindex 1d14cb5196..8dc6c1142e 100644--- a/rust/crates/assets/src/download.rs+++ b/rust/crates/assets/src/download.rs@@ -186,6 +186,19 @@ struct RangePartState {retry_count: u32,}+struct RangeDownloadContext<'a, 'progress> {+ client: &'a Client,+ target: &'a DownloadTarget,+ total: u64,+ response_metadata: Option<&'a ResponseMetadata>,+ range_states: &'a Mutex<Vec<RangePartState>>,+ range_metadata: &'a Mutex<RangeDownloadMetadata>,+ range_metadata_path: &'a Path,+ file_started_at: Instant,+ on_progress: &'a Mutex<&'progress mut (dyn FnMut(FileProgress) + Send)>,+ is_cancelled: &'a (dyn Fn() -> bool + Sync),+}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]struct ContentRange {start: u64,@@ -700,7 +713,6 @@ async fn download_file_ranged(.truncate(false).open(&tmp_path)?;file.set_len(total)?;- let file = Arc::new(file);let range_states = range_metadata.ranges@@ -715,11 +727,23 @@ async fn download_file_ranged(retry_count: 0,}).collect::<Vec<_>>();- let range_states = Arc::new(Mutex::new(range_states));- let range_metadata = Arc::new(Mutex::new(range_metadata));- let on_progress = Arc::new(Mutex::new(on_progress));+ let range_states = Mutex::new(range_states);+ let range_metadata = Mutex::new(range_metadata);+ let on_progress = Mutex::new(on_progress);+ let range_download = RangeDownloadContext {+ client,+ target,+ total,+ response_metadata: response_metadata.as_ref(),+ range_states: &range_states,+ range_metadata: &range_metadata,+ range_metadata_path: &range_metadata_path,+ file_started_at,+ on_progress: &on_progress,+ is_cancelled,+ };- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);+ range_download.emit_progress();let mut downloads = Vec::new();{@@ -729,38 +753,13 @@ async fn download_file_ranged(continue;}- let file = Arc::clone(&file);- let range_states = Arc::clone(&range_states);- let range_metadata = Arc::clone(&range_metadata);- let range_metadata_path = range_metadata_path.clone();- let response_metadata = response_metadata.clone();- let on_progress = Arc::clone(&on_progress);-- downloads.push(async move {- download_range_part(- client,- target,- file,- part_index,- range,- total,- response_metadata,- range_states,- range_metadata,- range_metadata_path,- file_started_at,- on_progress,- is_cancelled,- )- .await- });+ downloads.push(range_download.download_part(&file, part_index, range));}}try_join_all(downloads).await?;drop(file);-- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);+ range_download.emit_progress();if let Err(err) = check_sha256(&tmp_path, &target.sha256, &target.label).await {let _ = fs::remove_file(&tmp_path);@@ -802,149 +801,184 @@ async fn download_file_ranged(})}-#[allow(clippy::too_many_arguments)]-async fn download_range_part(- client: &Client,- target: &DownloadTarget,- file: Arc<File>,- part_index: usize,- range: RangeDownloadPartMetadata,- total: u64,- response_metadata: Option<ResponseMetadata>,- range_states: Arc<Mutex<Vec<RangePartState>>>,- range_metadata: Arc<Mutex<RangeDownloadMetadata>>,- range_metadata_path: PathBuf,- file_started_at: Instant,- on_progress: Arc<Mutex<&mut (dyn FnMut(FileProgress) + Send)>>,- is_cancelled: &(impl Fn() -> bool + Sync),-) -> Result<(), Error> {- let range_len = range_download_len(range);+impl RangeDownloadContext<'_, '_> {+ async fn download_part(+ &self,+ file: &File,+ part_index: usize,+ range: RangeDownloadPartMetadata,+ ) -> Result<(), Error> {+ let range_len = range_download_len(range);- for attempt in 1..=MAX_ATTEMPTS {- if is_cancelled() {- return Err(Error::Cancelled);- }+ for attempt in 1..=MAX_ATTEMPTS {+ if (self.is_cancelled)() {+ return Err(Error::Cancelled);+ }- {- let mut states = range_states.lock().expect("range state lock");- if let Some(state) = states.get_mut(part_index) {- state.downloaded_bytes = 0;+ {+ let mut states = self.range_states.lock().expect("range state lock");+ if let Some(state) = states.get_mut(part_index) {+ state.downloaded_bytes = 0;+ }}- }- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);+ self.emit_progress();- let mut response =- match request_model_range(client, &target.url, range, response_metadata.as_ref()).await+ let mut response = match request_model_range(+ self.client,+ &self.target.url,+ range,+ self.response_metadata,+ )+ .await{Ok(response) => response,Err(err) => {if attempt == MAX_ATTEMPTS {return Err(err);}- increment_range_retry(&range_states, part_index);- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);+ self.increment_retry(part_index);+ self.emit_progress();continue;}};- if response.status() != StatusCode::PARTIAL_CONTENT {- if response.status() == StatusCode::OK- || response.status() == StatusCode::RANGE_NOT_SATISFIABLE- {- return Err(Error::Http(response.status().as_u16()));- }- if attempt == MAX_ATTEMPTS {- return Err(Error::Http(response.status().as_u16()));+ if response.status() != StatusCode::PARTIAL_CONTENT {+ if response.status() == StatusCode::OK+ || response.status() == StatusCode::RANGE_NOT_SATISFIABLE+ {+ return Err(Error::Http(response.status().as_u16()));+ }+ if attempt == MAX_ATTEMPTS {+ return Err(Error::Http(response.status().as_u16()));+ }+ self.increment_retry(part_index);+ self.emit_progress();+ continue;}- increment_range_retry(&range_states, part_index);- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);- continue;- }- validate_range_response(&response, range, total)?;+ validate_range_response(&response, range, self.total)?;- let mut downloaded_in_range = 0u64;- let mut last_progress = Instant::now();- let mut retry_attempt = false;+ let mut downloaded_in_range = 0u64;+ let mut last_progress = Instant::now();+ let mut retry_attempt = false;- loop {- if is_cancelled() {- return Err(Error::Cancelled);- }+ loop {+ if (self.is_cancelled)() {+ return Err(Error::Cancelled);+ }- let chunk = match response.chunk().await {- Ok(chunk) => chunk,- Err(err) => {- if attempt == MAX_ATTEMPTS {- return Err(Error::Network(err.to_string()));+ let chunk = match response.chunk().await {+ Ok(chunk) => chunk,+ Err(err) => {+ if attempt == MAX_ATTEMPTS {+ return Err(Error::Network(err.to_string()));+ }+ self.increment_retry(part_index);+ retry_attempt = true;+ break;}- increment_range_retry(&range_states, part_index);- retry_attempt = true;+ };+ let Some(chunk) = chunk else {break;+ };++ let chunk_len = chunk.len() as u64;+ if downloaded_in_range.saturating_add(chunk_len) > range_len {+ return Err(Error::Protocol(+ "received more bytes than requested".to_string(),+ ));}- };- let Some(chunk) = chunk else {- break;- };- let chunk_len = chunk.len() as u64;- if downloaded_in_range.saturating_add(chunk_len) > range_len {- return Err(Error::Protocol(- "received more bytes than requested".to_string(),- ));- }+ write_all_at(file, chunk.as_ref(), range.start + downloaded_in_range)?;+ downloaded_in_range = downloaded_in_range.saturating_add(chunk_len);- write_all_at(- file.as_ref(),- chunk.as_ref(),- range.start + downloaded_in_range,- )?;- downloaded_in_range = downloaded_in_range.saturating_add(chunk_len);+ {+ let mut states = self.range_states.lock().expect("range state lock");+ if let Some(state) = states.get_mut(part_index) {+ state.downloaded_bytes = downloaded_in_range;+ state.network_downloaded_bytes =+ state.network_downloaded_bytes.saturating_add(chunk_len);+ }+ }- {- let mut states = range_states.lock().expect("range state lock");- if let Some(state) = states.get_mut(part_index) {- state.downloaded_bytes = downloaded_in_range;- state.network_downloaded_bytes =- state.network_downloaded_bytes.saturating_add(chunk_len);+ if last_progress.elapsed() >= PROGRESS_INTERVAL {+ self.emit_progress();+ last_progress = Instant::now();}}- if last_progress.elapsed() >= PROGRESS_INTERVAL {- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);- last_progress = Instant::now();+ if retry_attempt {+ self.emit_progress();+ continue;}- }- if retry_attempt {- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);- continue;- }+ if downloaded_in_range != range_len {+ if attempt == MAX_ATTEMPTS {+ return Err(Error::SizeMismatch {+ expected: range_len,+ actual: downloaded_in_range,+ });+ }+ self.increment_retry(part_index);+ self.emit_progress();+ continue;+ }- if downloaded_in_range != range_len {- if attempt == MAX_ATTEMPTS {- return Err(Error::SizeMismatch {- expected: range_len,- actual: downloaded_in_range,- });+ {+ let mut states = self.range_states.lock().expect("range state lock");+ if let Some(state) = states.get_mut(part_index) {+ state.downloaded_bytes = range_len;+ }}- increment_range_retry(&range_states, part_index);- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);- continue;+ self.mark_complete(part_index)?;+ self.emit_progress();+ return Ok(());}- {- let mut states = range_states.lock().expect("range state lock");- if let Some(state) = states.get_mut(part_index) {- state.downloaded_bytes = range_len;- }+ unreachable!("the final attempt returns")+ }++ fn emit_progress(&self) {+ let states = self.range_states.lock().expect("range state lock");+ let downloaded_bytes = states+ .iter()+ .map(|state| state.downloaded_bytes)+ .sum::<u64>()+ .min(self.total);+ let network_downloaded_bytes = states+ .iter()+ .map(|state| state.network_downloaded_bytes)+ .sum::<u64>();+ let retry_count = states+ .iter()+ .map(|state| state.retry_count)+ .fold(0u32, u32::saturating_add);+ drop(states);++ let mut callback = self.on_progress.lock().expect("progress lock");+ (**callback)(FileProgress {+ downloaded_bytes,+ total_bytes: Some(self.total),+ network_downloaded_bytes,+ elapsed: self.file_started_at.elapsed(),+ retry_count,+ });+ }++ fn increment_retry(&self, part_index: usize) {+ let mut states = self.range_states.lock().expect("range state lock");+ if let Some(state) = states.get_mut(part_index) {+ state.retry_count = state.retry_count.saturating_add(1);}- mark_range_complete(&range_metadata, &range_metadata_path, part_index)?;- emit_range_file_progress(total, file_started_at, &range_states, &on_progress);- return Ok(());}- unreachable!("the final attempt returns")+ fn mark_complete(&self, part_index: usize) -> Result<(), Error> {+ let mut metadata = self.range_metadata.lock().expect("range metadata lock");+ if let Some(range) = metadata.ranges.get_mut(part_index) {+ range.complete = true;+ }+ write_range_download_metadata(self.range_metadata_path, &metadata)+ }}async fn request_file(@@ -1130,57 +1164,6 @@ fn range_download_len(range: RangeDownloadPartMetadata) -> u64 {range.end.saturating_sub(range.start).saturating_add(1)}-fn emit_range_file_progress(- total_bytes: u64,- file_started_at: Instant,- range_states: &Arc<Mutex<Vec<RangePartState>>>,- on_progress: &Arc<Mutex<&mut (dyn FnMut(FileProgress) + Send)>>,-) {- let states = range_states.lock().expect("range state lock");- let downloaded_bytes = states- .iter()- .map(|state| state.downloaded_bytes)- .sum::<u64>()- .min(total_bytes);- let network_downloaded_bytes = states- .iter()- .map(|state| state.network_downloaded_bytes)- .sum::<u64>();- let retry_count = states- .iter()- .map(|state| state.retry_count)- .fold(0u32, u32::saturating_add);- drop(states);-- let mut callback = on_progress.lock().expect("progress lock");- (**callback)(FileProgress {- downloaded_bytes,- total_bytes: Some(total_bytes),- network_downloaded_bytes,- elapsed: file_started_at.elapsed(),- retry_count,- });-}--fn increment_range_retry(range_states: &Arc<Mutex<Vec<RangePartState>>>, part_index: usize) {- let mut states = range_states.lock().expect("range state lock");- if let Some(state) = states.get_mut(part_index) {- state.retry_count = state.retry_count.saturating_add(1);- }-}--fn mark_range_complete(- range_metadata: &Arc<Mutex<RangeDownloadMetadata>>,- range_metadata_path: &Path,- part_index: usize,-) -> Result<(), Error> {- let mut metadata = range_metadata.lock().expect("range metadata lock");- if let Some(range) = metadata.ranges.get_mut(part_index) {- range.complete = true;- }- write_range_download_metadata(range_metadata_path, &metadata)-}-fn validate_range_response(response: &Response,range: RangeDownloadPartMetadata,diff --git a/rust/crates/ensu/src/db/chat/mod.rs b/rust/crates/ensu/src/db/chat/mod.rsindex 3df9ddee27..a2f1a08cc9 100644--- a/rust/crates/ensu/src/db/chat/mod.rs+++ b/rust/crates/ensu/src/db/chat/mod.rs@@ -209,20 +209,9 @@ impl<B: Backend> ChatDb<B> {})}- #[allow(clippy::too_many_arguments)]- pub fn insert_message_with_uuid(- &self,- uuid: Uuid,- session_uuid: Uuid,- sender: &str,- text: &str,- parent: Option<Uuid>,- attachments: Vec<AttachmentMeta>,- created_at: i64,- ) -> Result<Message> {- let sender: Sender = sender.parse()?;- let encrypted_text = crypto::encrypt_string(text, &self.key)?;- let attachments_json = self.serialize_attachments(&attachments)?;+ pub fn insert_message_with_uuid(&self, message: &Message) -> Result<Message> {+ let encrypted_text = crypto::encrypt_string(&message.text, &self.key)?;+ let attachments_json = self.serialize_attachments(&message.attachments)?;self.backend.transaction(|tx| {let inserted = tx.execute(@@ -232,24 +221,24 @@ impl<B: Backend> ChatDb<B> {) VALUES (?, ?, ?, ?, ?, ?, ?)ON CONFLICT(message_uuid) DO NOTHING",&[- Value::Text(uuid.to_string()),- Value::Text(session_uuid.to_string()),- optional_uuid(parent),- Value::Text(sender.as_str().to_string()),+ Value::Text(message.uuid.to_string()),+ Value::Text(message.session_uuid.to_string()),+ optional_uuid(message.parent_message_uuid),+ Value::Text(message.sender.as_str().to_string()),Value::Blob(encrypted_text),attachments_json.map(Value::Text).unwrap_or(Value::Null),- Value::Integer(created_at),+ Value::Integer(message.created_at),],)?;if inserted == 1 {- self.touch_session_at_least(tx, session_uuid, created_at)?;+ self.touch_session_at_least(tx, message.session_uuid, message.created_at)?;}Ok(())})?;- self.get_message(uuid)?.ok_or(Error::NotFound {+ self.get_message(message.uuid)?.ok_or(Error::NotFound {entity: EntityType::Message,- id: uuid,+ id: message.uuid,})}diff --git a/rust/crates/ensu/src/llm/generate.rs b/rust/crates/ensu/src/llm/generate.rsindex 63ebcdafa0..1c07406232 100644--- a/rust/crates/ensu/src/llm/generate.rs+++ b/rust/crates/ensu/src/llm/generate.rs@@ -315,96 +315,102 @@ impl StreamDecoder {}}-#[allow(clippy::too_many_arguments)]-fn run_generation_loop(- ctx: &mut LlamaContext,- sampler: &mut LlamaSampler,- cancel_flag: &AtomicBool,- sink: &mut dyn EventSink,+struct GenerationJob<'a> {+ cancel_flag: &'a AtomicBool,+ sink: &'a mut dyn EventSink,job_id: JobId,max_tokens: usize,- stop_sequences: &[String],- generated_tokens_count: &mut i32,- mut cached_tokens: Option<&mut Vec<LlamaToken>>,- mut pos: i32,- mut logits_index: i32,-) -> Result<(), Error> {- let mut decoder = StreamDecoder::new(stop_sequences);- let mut stop_triggered = false;- let n_ctx = ctx.n_ctx();-- for _ in 0..max_tokens {- if cancel_flag.load(Ordering::Relaxed) {- return Err(Error::Cancelled);- }- if pos >= n_ctx as i32 {- break;- }-- let token = sampler.sample(ctx, logits_index);- sampler.accept(token);- *generated_tokens_count = generated_tokens_count.saturating_add(1);+ stop_sequences: &'a [String],+ prompt_tokens: i32,+ generated_tokens: i32,+}- if ctx.model.is_eog_token(token) {- break;- }+impl GenerationJob<'_> {+ fn run(+ &mut self,+ ctx: &mut LlamaContext,+ sampler: &mut LlamaSampler,+ mut cached_tokens: Option<&mut Vec<LlamaToken>>,+ mut pos: i32,+ mut logits_index: i32,+ ) -> Result<(), Error> {+ let mut decoder = StreamDecoder::new(self.stop_sequences);+ let mut stop_triggered = false;+ let n_ctx = ctx.n_ctx();++ for _ in 0..self.max_tokens {+ if self.cancel_flag.load(Ordering::Relaxed) {+ return Err(Error::Cancelled);+ }+ if pos >= n_ctx as i32 {+ break;+ }- let bytes = token_piece_bytes(ctx.model, token).map_err(|err| Error::Llama {- op: "Detokenize failed",- message: err.to_string(),- })?;- let step = decoder.push_bytes(&bytes);-- if let Some(text) = step.text {- sink.add(GenerationEvent::Text {- job_id,- text,- token_id: Some(token.0),- });- }+ let token = sampler.sample(ctx, logits_index);+ sampler.accept(token);+ self.generated_tokens = self.generated_tokens.saturating_add(1);- if step.stop {- stop_triggered = true;- break;- }+ if ctx.model.is_eog_token(token) {+ break;+ }- let mut step_batch = LlamaBatch::new(1, 1);- step_batch- .add(token, pos, &[0], true)- .map_err(|err| Error::Llama {- op: "Failed to add token",+ let bytes = token_piece_bytes(ctx.model, token).map_err(|err| Error::Llama {+ op: "Detokenize failed",message: err.to_string(),})?;- if let Err(err) = ctx.decode(&mut step_batch) {- ctx.clear_kv_cache();+ let step = decoder.push_bytes(&bytes);++ if let Some(text) = step.text {+ self.emit_text(text, Some(token.0));+ }++ if step.stop {+ stop_triggered = true;+ break;+ }++ let mut step_batch = LlamaBatch::new(1, 1);+ step_batch+ .add(token, pos, &[0], true)+ .map_err(|err| Error::Llama {+ op: "Failed to add token",+ message: err.to_string(),+ })?;+ if let Err(err) = ctx.decode(&mut step_batch) {+ ctx.clear_kv_cache();+ if let Some(cached) = cached_tokens.as_deref_mut() {+ cached.clear();+ }+ return Err(Error::Llama {+ op: "Decode failed",+ message: err.to_string(),+ });+ }if let Some(cached) = cached_tokens.as_deref_mut() {- cached.clear();+ cached.push(token);}- return Err(Error::Llama {- op: "Decode failed",- message: err.to_string(),- });++ logits_index = 0;+ pos += 1;}- if let Some(cached) = cached_tokens.as_deref_mut() {- cached.push(token);++ if !stop_triggered {+ let step = decoder.flush();+ if let Some(text) = step.text {+ self.emit_text(text, None);+ }}- logits_index = 0;- pos += 1;+ Ok(())}- if !stop_triggered {- let step = decoder.flush();- if let Some(text) = step.text {- sink.add(GenerationEvent::Text {- job_id,- text,- token_id: None,- });- }+ fn emit_text(&mut self, text: String, token_id: Option<i32>) {+ self.sink.add(GenerationEvent::Text {+ job_id: self.job_id,+ text,+ token_id,+ });}-- Ok(())}fn build_sampler(model: &LlamaModel, request: &SamplingParams) -> Result<LlamaSampler, Error> {@@ -516,8 +522,15 @@ fn generate_chat_stream(let max_tokens = usize::try_from(max_tokens.max(0)).unwrap_or(0);let stop_sequences = stop_sequences.unwrap_or_default();- let mut prompt_tokens_count: i32 = 0;- let mut generated_tokens_count: i32 = 0;+ let mut job = GenerationJob {+ cancel_flag: &cancel_flag,+ sink,+ job_id,+ max_tokens,+ stop_sequences: &stop_sequences,+ prompt_tokens: 0,+ generated_tokens: 0,+ };let result = match catch_unwind(AssertUnwindSafe(|| {context.with_context_and_cache_mut(|ctx, cached_tokens| -> Result<(), Error> {@@ -592,7 +605,7 @@ fn generate_chat_stream(context_size: n_ctx,});}- prompt_tokens_count =+ job.prompt_tokens =i32::try_from(prompt_tokens.len()).map_err(|_| Error::PromptTooLong {tokens: prompt_tokens.len(),context_size: n_ctx,@@ -649,19 +662,7 @@ fn generate_chat_stream(sampler.accept_many(prompt_tokens.iter());let pos = prompt_tokens.len() as i32;- run_generation_loop(- ctx,- &mut sampler,- &cancel_flag,- sink,- job_id,- max_tokens,- &stop_sequences,- &mut generated_tokens_count,- Some(cached_tokens),- pos,- logits_index,- )?;+ job.run(ctx, &mut sampler, Some(cached_tokens), pos, logits_index)?;return Ok(());}@@ -721,7 +722,7 @@ fn generate_chat_stream(context_size: n_ctx,});}- prompt_tokens_count =+ job.prompt_tokens =i32::try_from(chunks.total_tokens()).map_err(|_| Error::PromptTooLong {tokens: chunks.total_tokens(),context_size: n_ctx,@@ -755,19 +756,7 @@ fn generate_chat_stream(}sampler.accept_many(prompt_tokens.iter());- run_generation_loop(- ctx,- &mut sampler,- &cancel_flag,- sink,- job_id,- max_tokens,- &stop_sequences,- &mut generated_tokens_count,- None,- n_past,- -1,- )?;+ job.run(ctx, &mut sampler, None, n_past, -1)?;Ok(())})@@ -782,8 +771,8 @@ fn generate_chat_stream(let summary = GenerationSummary {job_id,- prompt_tokens: Some(prompt_tokens_count),- generated_tokens: Some(generated_tokens_count),+ prompt_tokens: Some(job.prompt_tokens),+ generated_tokens: Some(job.generated_tokens),total_time_ms: Some(start.elapsed().as_millis() as i64),};diff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.tsindex 825db8c40c..75d6c3cc48 100644--- a/web/apps/space/src/services/space.ts+++ b/web/apps/space/src/services/space.ts@@ -1309,10 +1309,12 @@ export const createCurrentPhotoPost = async ({spaceId,bytes,caption?.trim() || null,- normalizedWidth,- normalizedHeight,- file.type || null,- thumbHash || null,+ {+ width: normalizedWidth,+ height: normalizedHeight,+ mediaType: file.type || null,+ thumbHash: thumbHash || null,+ },)) as SpacePostResponse;const object = firstObject(created);if (object) await cacheAccountPostAssetURL(created, object, file);