@ondeinference / onde
Code Commits Issues Pulls Cloud Agent CI/CD
copilot/assess-inference-engine-complexity
copilot/assess-inference-engine-complexity copilot/fix-onde-npm-sdk-v1-1-2-release development feature/diffusion-vision main
rs 2,078 lines 84.5 KB
Raw
1 // This file is automatically generated, so please do not edit it.
2 // @generated by `flutter_rust_bridge`@ 2.12.0.
3
4 #![allow(
5 non_camel_case_types,
6 unused,
7 non_snake_case,
8 clippy::needless_return,
9 clippy::redundant_closure_call,
10 clippy::redundant_closure,
11 clippy::useless_conversion,
12 clippy::unit_arg,
13 clippy::unused_unit,
14 clippy::double_parens,
15 clippy::let_and_return,
16 clippy::too_many_arguments,
17 clippy::match_single_binding,
18 clippy::clone_on_copy,
19 clippy::let_unit_value,
20 clippy::deref_addrof,
21 clippy::explicit_auto_deref,
22 clippy::borrow_deref_ref,
23 clippy::uninlined_format_args,
24 clippy::needless_borrow
25 )]
26
27 // Section: imports
28
29 use crate::api::*;
30 use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
31 use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
32 use flutter_rust_bridge::{Handler, IntoIntoDart};
33
34 // Section: boilerplate
35
36 flutter_rust_bridge::frb_generated_boilerplate!(
37 default_stream_sink_codec = SseCodec,
38 default_rust_opaque = RustOpaqueMoi,
39 default_rust_auto_opaque = RustAutoOpaqueMoi,
40 );
41 pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.12.0";
42 pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -2049740590;
43
44 // Section: executor
45
46 flutter_rust_bridge::frb_generated_default_handler!();
47
48 // Section: wire_funcs
49
50 fn wire__crate__api__OndeChatEngine_clear_history_impl(
51 port_: flutter_rust_bridge::for_generated::MessagePort,
52 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
53 rust_vec_len_: i32,
54 data_len_: i32,
55 ) {
56 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
57 flutter_rust_bridge::for_generated::TaskInfo {
58 debug_name: "OndeChatEngine_clear_history",
59 port: Some(port_),
60 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
61 },
62 move || {
63 let message = unsafe {
64 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
65 ptr_,
66 rust_vec_len_,
67 data_len_,
68 )
69 };
70 let mut deserializer =
71 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
72 let api_that = <RustOpaqueMoi<
73 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
74 >>::sse_decode(&mut deserializer);
75 deserializer.end();
76 move |context| async move {
77 transform_result_sse::<_, ()>(
78 (move || async move {
79 let mut api_that_guard = None;
80 let decode_indices_ =
81 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
82 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
83 &api_that, 0, false,
84 )],
85 );
86 for i in decode_indices_ {
87 match i {
88 0 => {
89 api_that_guard =
90 Some(api_that.lockable_decode_async_ref().await)
91 }
92 _ => unreachable!(),
93 }
94 }
95 let api_that_guard = api_that_guard.unwrap();
96 let output_ok = Result::<_, ()>::Ok(
97 crate::api::OndeChatEngine::clear_history(&*api_that_guard).await,
98 )?;
99 Ok(output_ok)
100 })()
101 .await,
102 )
103 }
104 },
105 )
106 }
107 fn wire__crate__api__OndeChatEngine_clear_system_prompt_impl(
108 port_: flutter_rust_bridge::for_generated::MessagePort,
109 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
110 rust_vec_len_: i32,
111 data_len_: i32,
112 ) {
113 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
114 flutter_rust_bridge::for_generated::TaskInfo {
115 debug_name: "OndeChatEngine_clear_system_prompt",
116 port: Some(port_),
117 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
118 },
119 move || {
120 let message = unsafe {
121 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
122 ptr_,
123 rust_vec_len_,
124 data_len_,
125 )
126 };
127 let mut deserializer =
128 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
129 let api_that = <RustOpaqueMoi<
130 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
131 >>::sse_decode(&mut deserializer);
132 deserializer.end();
133 move |context| async move {
134 transform_result_sse::<_, ()>(
135 (move || async move {
136 let mut api_that_guard = None;
137 let decode_indices_ =
138 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
139 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
140 &api_that, 0, false,
141 )],
142 );
143 for i in decode_indices_ {
144 match i {
145 0 => {
146 api_that_guard =
147 Some(api_that.lockable_decode_async_ref().await)
148 }
149 _ => unreachable!(),
150 }
151 }
152 let api_that_guard = api_that_guard.unwrap();
153 let output_ok = Result::<_, ()>::Ok({
154 crate::api::OndeChatEngine::clear_system_prompt(&*api_that_guard).await;
155 })?;
156 Ok(output_ok)
157 })()
158 .await,
159 )
160 }
161 },
162 )
163 }
164 fn wire__crate__api__OndeChatEngine_generate_impl(
165 port_: flutter_rust_bridge::for_generated::MessagePort,
166 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
167 rust_vec_len_: i32,
168 data_len_: i32,
169 ) {
170 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
171 flutter_rust_bridge::for_generated::TaskInfo {
172 debug_name: "OndeChatEngine_generate",
173 port: Some(port_),
174 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
175 },
176 move || {
177 let message = unsafe {
178 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
179 ptr_,
180 rust_vec_len_,
181 data_len_,
182 )
183 };
184 let mut deserializer =
185 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
186 let api_that = <RustOpaqueMoi<
187 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
188 >>::sse_decode(&mut deserializer);
189 let api_messages = <Vec<crate::api::ChatMessage>>::sse_decode(&mut deserializer);
190 let api_sampling = <Option<crate::api::SamplingConfig>>::sse_decode(&mut deserializer);
191 deserializer.end();
192 move |context| async move {
193 transform_result_sse::<_, crate::api::OndeError>(
194 (move || async move {
195 let mut api_that_guard = None;
196 let decode_indices_ =
197 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
198 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
199 &api_that, 0, false,
200 )],
201 );
202 for i in decode_indices_ {
203 match i {
204 0 => {
205 api_that_guard =
206 Some(api_that.lockable_decode_async_ref().await)
207 }
208 _ => unreachable!(),
209 }
210 }
211 let api_that_guard = api_that_guard.unwrap();
212 let output_ok = crate::api::OndeChatEngine::generate(
213 &*api_that_guard,
214 api_messages,
215 api_sampling,
216 )
217 .await?;
218 Ok(output_ok)
219 })()
220 .await,
221 )
222 }
223 },
224 )
225 }
226 fn wire__crate__api__OndeChatEngine_history_impl(
227 port_: flutter_rust_bridge::for_generated::MessagePort,
228 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
229 rust_vec_len_: i32,
230 data_len_: i32,
231 ) {
232 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
233 flutter_rust_bridge::for_generated::TaskInfo {
234 debug_name: "OndeChatEngine_history",
235 port: Some(port_),
236 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
237 },
238 move || {
239 let message = unsafe {
240 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
241 ptr_,
242 rust_vec_len_,
243 data_len_,
244 )
245 };
246 let mut deserializer =
247 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
248 let api_that = <RustOpaqueMoi<
249 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
250 >>::sse_decode(&mut deserializer);
251 deserializer.end();
252 move |context| async move {
253 transform_result_sse::<_, ()>(
254 (move || async move {
255 let mut api_that_guard = None;
256 let decode_indices_ =
257 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
258 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
259 &api_that, 0, false,
260 )],
261 );
262 for i in decode_indices_ {
263 match i {
264 0 => {
265 api_that_guard =
266 Some(api_that.lockable_decode_async_ref().await)
267 }
268 _ => unreachable!(),
269 }
270 }
271 let api_that_guard = api_that_guard.unwrap();
272 let output_ok = Result::<_, ()>::Ok(
273 crate::api::OndeChatEngine::history(&*api_that_guard).await,
274 )?;
275 Ok(output_ok)
276 })()
277 .await,
278 )
279 }
280 },
281 )
282 }
283 fn wire__crate__api__OndeChatEngine_info_impl(
284 port_: flutter_rust_bridge::for_generated::MessagePort,
285 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
286 rust_vec_len_: i32,
287 data_len_: i32,
288 ) {
289 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
290 flutter_rust_bridge::for_generated::TaskInfo {
291 debug_name: "OndeChatEngine_info",
292 port: Some(port_),
293 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
294 },
295 move || {
296 let message = unsafe {
297 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
298 ptr_,
299 rust_vec_len_,
300 data_len_,
301 )
302 };
303 let mut deserializer =
304 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
305 let api_that = <RustOpaqueMoi<
306 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
307 >>::sse_decode(&mut deserializer);
308 deserializer.end();
309 move |context| async move {
310 transform_result_sse::<_, ()>(
311 (move || async move {
312 let mut api_that_guard = None;
313 let decode_indices_ =
314 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
315 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
316 &api_that, 0, false,
317 )],
318 );
319 for i in decode_indices_ {
320 match i {
321 0 => {
322 api_that_guard =
323 Some(api_that.lockable_decode_async_ref().await)
324 }
325 _ => unreachable!(),
326 }
327 }
328 let api_that_guard = api_that_guard.unwrap();
329 let output_ok = Result::<_, ()>::Ok(
330 crate::api::OndeChatEngine::info(&*api_that_guard).await,
331 )?;
332 Ok(output_ok)
333 })()
334 .await,
335 )
336 }
337 },
338 )
339 }
340 fn wire__crate__api__OndeChatEngine_is_loaded_impl(
341 port_: flutter_rust_bridge::for_generated::MessagePort,
342 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
343 rust_vec_len_: i32,
344 data_len_: i32,
345 ) {
346 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
347 flutter_rust_bridge::for_generated::TaskInfo {
348 debug_name: "OndeChatEngine_is_loaded",
349 port: Some(port_),
350 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
351 },
352 move || {
353 let message = unsafe {
354 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
355 ptr_,
356 rust_vec_len_,
357 data_len_,
358 )
359 };
360 let mut deserializer =
361 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
362 let api_that = <RustOpaqueMoi<
363 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
364 >>::sse_decode(&mut deserializer);
365 deserializer.end();
366 move |context| async move {
367 transform_result_sse::<_, ()>(
368 (move || async move {
369 let mut api_that_guard = None;
370 let decode_indices_ =
371 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
372 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
373 &api_that, 0, false,
374 )],
375 );
376 for i in decode_indices_ {
377 match i {
378 0 => {
379 api_that_guard =
380 Some(api_that.lockable_decode_async_ref().await)
381 }
382 _ => unreachable!(),
383 }
384 }
385 let api_that_guard = api_that_guard.unwrap();
386 let output_ok = Result::<_, ()>::Ok(
387 crate::api::OndeChatEngine::is_loaded(&*api_that_guard).await,
388 )?;
389 Ok(output_ok)
390 })()
391 .await,
392 )
393 }
394 },
395 )
396 }
397 fn wire__crate__api__OndeChatEngine_load_gguf_model_impl(
398 port_: flutter_rust_bridge::for_generated::MessagePort,
399 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
400 rust_vec_len_: i32,
401 data_len_: i32,
402 ) {
403 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
404 flutter_rust_bridge::for_generated::TaskInfo {
405 debug_name: "OndeChatEngine_load_gguf_model",
406 port: Some(port_),
407 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
408 },
409 move || {
410 let message = unsafe {
411 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
412 ptr_,
413 rust_vec_len_,
414 data_len_,
415 )
416 };
417 let mut deserializer =
418 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
419 let api_that = <RustOpaqueMoi<
420 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
421 >>::sse_decode(&mut deserializer);
422 let api_config = <crate::api::GgufModelConfig>::sse_decode(&mut deserializer);
423 let api_system_prompt = <Option<String>>::sse_decode(&mut deserializer);
424 let api_sampling = <Option<crate::api::SamplingConfig>>::sse_decode(&mut deserializer);
425 deserializer.end();
426 move |context| async move {
427 transform_result_sse::<_, crate::api::OndeError>(
428 (move || async move {
429 let mut api_that_guard = None;
430 let decode_indices_ =
431 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
432 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
433 &api_that, 0, false,
434 )],
435 );
436 for i in decode_indices_ {
437 match i {
438 0 => {
439 api_that_guard =
440 Some(api_that.lockable_decode_async_ref().await)
441 }
442 _ => unreachable!(),
443 }
444 }
445 let api_that_guard = api_that_guard.unwrap();
446 let output_ok = crate::api::OndeChatEngine::load_gguf_model(
447 &*api_that_guard,
448 api_config,
449 api_system_prompt,
450 api_sampling,
451 )
452 .await?;
453 Ok(output_ok)
454 })()
455 .await,
456 )
457 }
458 },
459 )
460 }
461 fn wire__crate__api__OndeChatEngine_new_impl(
462 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
463 rust_vec_len_: i32,
464 data_len_: i32,
465 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
466 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
467 flutter_rust_bridge::for_generated::TaskInfo {
468 debug_name: "OndeChatEngine_new",
469 port: None,
470 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
471 },
472 move || {
473 let message = unsafe {
474 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
475 ptr_,
476 rust_vec_len_,
477 data_len_,
478 )
479 };
480 let mut deserializer =
481 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
482 deserializer.end();
483 transform_result_sse::<_, ()>((move || {
484 let output_ok = Result::<_, ()>::Ok(crate::api::OndeChatEngine::new())?;
485 Ok(output_ok)
486 })())
487 },
488 )
489 }
490 fn wire__crate__api__OndeChatEngine_push_history_impl(
491 port_: flutter_rust_bridge::for_generated::MessagePort,
492 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
493 rust_vec_len_: i32,
494 data_len_: i32,
495 ) {
496 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
497 flutter_rust_bridge::for_generated::TaskInfo {
498 debug_name: "OndeChatEngine_push_history",
499 port: Some(port_),
500 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
501 },
502 move || {
503 let message = unsafe {
504 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
505 ptr_,
506 rust_vec_len_,
507 data_len_,
508 )
509 };
510 let mut deserializer =
511 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
512 let api_that = <RustOpaqueMoi<
513 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
514 >>::sse_decode(&mut deserializer);
515 let api_message = <crate::api::ChatMessage>::sse_decode(&mut deserializer);
516 deserializer.end();
517 move |context| async move {
518 transform_result_sse::<_, ()>(
519 (move || async move {
520 let mut api_that_guard = None;
521 let decode_indices_ =
522 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
523 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
524 &api_that, 0, false,
525 )],
526 );
527 for i in decode_indices_ {
528 match i {
529 0 => {
530 api_that_guard =
531 Some(api_that.lockable_decode_async_ref().await)
532 }
533 _ => unreachable!(),
534 }
535 }
536 let api_that_guard = api_that_guard.unwrap();
537 let output_ok = Result::<_, ()>::Ok({
538 crate::api::OndeChatEngine::push_history(&*api_that_guard, api_message)
539 .await;
540 })?;
541 Ok(output_ok)
542 })()
543 .await,
544 )
545 }
546 },
547 )
548 }
549 fn wire__crate__api__OndeChatEngine_send_message_impl(
550 port_: flutter_rust_bridge::for_generated::MessagePort,
551 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
552 rust_vec_len_: i32,
553 data_len_: i32,
554 ) {
555 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
556 flutter_rust_bridge::for_generated::TaskInfo {
557 debug_name: "OndeChatEngine_send_message",
558 port: Some(port_),
559 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
560 },
561 move || {
562 let message = unsafe {
563 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
564 ptr_,
565 rust_vec_len_,
566 data_len_,
567 )
568 };
569 let mut deserializer =
570 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
571 let api_that = <RustOpaqueMoi<
572 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
573 >>::sse_decode(&mut deserializer);
574 let api_message = <String>::sse_decode(&mut deserializer);
575 deserializer.end();
576 move |context| async move {
577 transform_result_sse::<_, crate::api::OndeError>(
578 (move || async move {
579 let mut api_that_guard = None;
580 let decode_indices_ =
581 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
582 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
583 &api_that, 0, false,
584 )],
585 );
586 for i in decode_indices_ {
587 match i {
588 0 => {
589 api_that_guard =
590 Some(api_that.lockable_decode_async_ref().await)
591 }
592 _ => unreachable!(),
593 }
594 }
595 let api_that_guard = api_that_guard.unwrap();
596 let output_ok =
597 crate::api::OndeChatEngine::send_message(&*api_that_guard, api_message)
598 .await?;
599 Ok(output_ok)
600 })()
601 .await,
602 )
603 }
604 },
605 )
606 }
607 fn wire__crate__api__OndeChatEngine_set_sampling_impl(
608 port_: flutter_rust_bridge::for_generated::MessagePort,
609 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
610 rust_vec_len_: i32,
611 data_len_: i32,
612 ) {
613 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
614 flutter_rust_bridge::for_generated::TaskInfo {
615 debug_name: "OndeChatEngine_set_sampling",
616 port: Some(port_),
617 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
618 },
619 move || {
620 let message = unsafe {
621 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
622 ptr_,
623 rust_vec_len_,
624 data_len_,
625 )
626 };
627 let mut deserializer =
628 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
629 let api_that = <RustOpaqueMoi<
630 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
631 >>::sse_decode(&mut deserializer);
632 let api_sampling = <crate::api::SamplingConfig>::sse_decode(&mut deserializer);
633 deserializer.end();
634 move |context| async move {
635 transform_result_sse::<_, ()>(
636 (move || async move {
637 let mut api_that_guard = None;
638 let decode_indices_ =
639 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
640 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
641 &api_that, 0, false,
642 )],
643 );
644 for i in decode_indices_ {
645 match i {
646 0 => {
647 api_that_guard =
648 Some(api_that.lockable_decode_async_ref().await)
649 }
650 _ => unreachable!(),
651 }
652 }
653 let api_that_guard = api_that_guard.unwrap();
654 let output_ok = Result::<_, ()>::Ok({
655 crate::api::OndeChatEngine::set_sampling(
656 &*api_that_guard,
657 api_sampling,
658 )
659 .await;
660 })?;
661 Ok(output_ok)
662 })()
663 .await,
664 )
665 }
666 },
667 )
668 }
669 fn wire__crate__api__OndeChatEngine_set_system_prompt_impl(
670 port_: flutter_rust_bridge::for_generated::MessagePort,
671 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
672 rust_vec_len_: i32,
673 data_len_: i32,
674 ) {
675 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
676 flutter_rust_bridge::for_generated::TaskInfo {
677 debug_name: "OndeChatEngine_set_system_prompt",
678 port: Some(port_),
679 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
680 },
681 move || {
682 let message = unsafe {
683 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
684 ptr_,
685 rust_vec_len_,
686 data_len_,
687 )
688 };
689 let mut deserializer =
690 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
691 let api_that = <RustOpaqueMoi<
692 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
693 >>::sse_decode(&mut deserializer);
694 let api_prompt = <String>::sse_decode(&mut deserializer);
695 deserializer.end();
696 move |context| async move {
697 transform_result_sse::<_, ()>(
698 (move || async move {
699 let mut api_that_guard = None;
700 let decode_indices_ =
701 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
702 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
703 &api_that, 0, false,
704 )],
705 );
706 for i in decode_indices_ {
707 match i {
708 0 => {
709 api_that_guard =
710 Some(api_that.lockable_decode_async_ref().await)
711 }
712 _ => unreachable!(),
713 }
714 }
715 let api_that_guard = api_that_guard.unwrap();
716 let output_ok = Result::<_, ()>::Ok({
717 crate::api::OndeChatEngine::set_system_prompt(
718 &*api_that_guard,
719 api_prompt,
720 )
721 .await;
722 })?;
723 Ok(output_ok)
724 })()
725 .await,
726 )
727 }
728 },
729 )
730 }
731 fn wire__crate__api__OndeChatEngine_stream_message_impl(
732 port_: flutter_rust_bridge::for_generated::MessagePort,
733 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
734 rust_vec_len_: i32,
735 data_len_: i32,
736 ) {
737 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
738 flutter_rust_bridge::for_generated::TaskInfo {
739 debug_name: "OndeChatEngine_stream_message",
740 port: Some(port_),
741 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
742 },
743 move || {
744 let message = unsafe {
745 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
746 ptr_,
747 rust_vec_len_,
748 data_len_,
749 )
750 };
751 let mut deserializer =
752 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
753 let api_that = <RustOpaqueMoi<
754 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
755 >>::sse_decode(&mut deserializer);
756 let api_message = <String>::sse_decode(&mut deserializer);
757 let api_sink = <StreamSink<
758 crate::api::StreamChunk,
759 flutter_rust_bridge::for_generated::SseCodec,
760 >>::sse_decode(&mut deserializer);
761 deserializer.end();
762 move |context| async move {
763 transform_result_sse::<_, crate::api::OndeError>(
764 (move || async move {
765 let mut api_that_guard = None;
766 let decode_indices_ =
767 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
768 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
769 &api_that, 0, false,
770 )],
771 );
772 for i in decode_indices_ {
773 match i {
774 0 => {
775 api_that_guard =
776 Some(api_that.lockable_decode_async_ref().await)
777 }
778 _ => unreachable!(),
779 }
780 }
781 let api_that_guard = api_that_guard.unwrap();
782 let output_ok = crate::api::OndeChatEngine::stream_message(
783 &*api_that_guard,
784 api_message,
785 api_sink,
786 )
787 .await?;
788 Ok(output_ok)
789 })()
790 .await,
791 )
792 }
793 },
794 )
795 }
796 fn wire__crate__api__OndeChatEngine_unload_model_impl(
797 port_: flutter_rust_bridge::for_generated::MessagePort,
798 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
799 rust_vec_len_: i32,
800 data_len_: i32,
801 ) {
802 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
803 flutter_rust_bridge::for_generated::TaskInfo {
804 debug_name: "OndeChatEngine_unload_model",
805 port: Some(port_),
806 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
807 },
808 move || {
809 let message = unsafe {
810 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
811 ptr_,
812 rust_vec_len_,
813 data_len_,
814 )
815 };
816 let mut deserializer =
817 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
818 let api_that = <RustOpaqueMoi<
819 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
820 >>::sse_decode(&mut deserializer);
821 deserializer.end();
822 move |context| async move {
823 transform_result_sse::<_, ()>(
824 (move || async move {
825 let mut api_that_guard = None;
826 let decode_indices_ =
827 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
828 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
829 &api_that, 0, false,
830 )],
831 );
832 for i in decode_indices_ {
833 match i {
834 0 => {
835 api_that_guard =
836 Some(api_that.lockable_decode_async_ref().await)
837 }
838 _ => unreachable!(),
839 }
840 }
841 let api_that_guard = api_that_guard.unwrap();
842 let output_ok = Result::<_, ()>::Ok(
843 crate::api::OndeChatEngine::unload_model(&*api_that_guard).await,
844 )?;
845 Ok(output_ok)
846 })()
847 .await,
848 )
849 }
850 },
851 )
852 }
853 fn wire__crate__api__configure_cache_dir_impl(
854 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
855 rust_vec_len_: i32,
856 data_len_: i32,
857 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
858 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
859 flutter_rust_bridge::for_generated::TaskInfo {
860 debug_name: "configure_cache_dir",
861 port: None,
862 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
863 },
864 move || {
865 let message = unsafe {
866 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
867 ptr_,
868 rust_vec_len_,
869 data_len_,
870 )
871 };
872 let mut deserializer =
873 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
874 let api_app_data_dir = <String>::sse_decode(&mut deserializer);
875 deserializer.end();
876 transform_result_sse::<_, crate::api::OndeError>((move || {
877 let output_ok = crate::api::configure_cache_dir(api_app_data_dir)?;
878 Ok(output_ok)
879 })())
880 },
881 )
882 }
883 fn wire__crate__api__default_model_config_impl(
884 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
885 rust_vec_len_: i32,
886 data_len_: i32,
887 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
888 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
889 flutter_rust_bridge::for_generated::TaskInfo {
890 debug_name: "default_model_config",
891 port: None,
892 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
893 },
894 move || {
895 let message = unsafe {
896 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
897 ptr_,
898 rust_vec_len_,
899 data_len_,
900 )
901 };
902 let mut deserializer =
903 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
904 deserializer.end();
905 transform_result_sse::<_, ()>((move || {
906 let output_ok = Result::<_, ()>::Ok(crate::api::default_model_config())?;
907 Ok(output_ok)
908 })())
909 },
910 )
911 }
912 fn wire__crate__api__default_sampling_config_impl(
913 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
914 rust_vec_len_: i32,
915 data_len_: i32,
916 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
917 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
918 flutter_rust_bridge::for_generated::TaskInfo {
919 debug_name: "default_sampling_config",
920 port: None,
921 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
922 },
923 move || {
924 let message = unsafe {
925 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
926 ptr_,
927 rust_vec_len_,
928 data_len_,
929 )
930 };
931 let mut deserializer =
932 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
933 deserializer.end();
934 transform_result_sse::<_, ()>((move || {
935 let output_ok = Result::<_, ()>::Ok(crate::api::default_sampling_config())?;
936 Ok(output_ok)
937 })())
938 },
939 )
940 }
941 fn wire__crate__api__deterministic_sampling_config_impl(
942 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
943 rust_vec_len_: i32,
944 data_len_: i32,
945 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
946 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
947 flutter_rust_bridge::for_generated::TaskInfo {
948 debug_name: "deterministic_sampling_config",
949 port: None,
950 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
951 },
952 move || {
953 let message = unsafe {
954 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
955 ptr_,
956 rust_vec_len_,
957 data_len_,
958 )
959 };
960 let mut deserializer =
961 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
962 deserializer.end();
963 transform_result_sse::<_, ()>((move || {
964 let output_ok = Result::<_, ()>::Ok(crate::api::deterministic_sampling_config())?;
965 Ok(output_ok)
966 })())
967 },
968 )
969 }
970 fn wire__crate__api__mobile_sampling_config_impl(
971 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
972 rust_vec_len_: i32,
973 data_len_: i32,
974 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
975 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
976 flutter_rust_bridge::for_generated::TaskInfo {
977 debug_name: "mobile_sampling_config",
978 port: None,
979 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
980 },
981 move || {
982 let message = unsafe {
983 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
984 ptr_,
985 rust_vec_len_,
986 data_len_,
987 )
988 };
989 let mut deserializer =
990 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
991 deserializer.end();
992 transform_result_sse::<_, ()>((move || {
993 let output_ok = Result::<_, ()>::Ok(crate::api::mobile_sampling_config())?;
994 Ok(output_ok)
995 })())
996 },
997 )
998 }
999 fn wire__crate__api__qwen25_1_5b_config_impl(
1000 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1001 rust_vec_len_: i32,
1002 data_len_: i32,
1003 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1004 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1005 flutter_rust_bridge::for_generated::TaskInfo {
1006 debug_name: "qwen25_1_5b_config",
1007 port: None,
1008 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1009 },
1010 move || {
1011 let message = unsafe {
1012 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1013 ptr_,
1014 rust_vec_len_,
1015 data_len_,
1016 )
1017 };
1018 let mut deserializer =
1019 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1020 deserializer.end();
1021 transform_result_sse::<_, ()>((move || {
1022 let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_1_5b_config())?;
1023 Ok(output_ok)
1024 })())
1025 },
1026 )
1027 }
1028 fn wire__crate__api__qwen25_3b_config_impl(
1029 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1030 rust_vec_len_: i32,
1031 data_len_: i32,
1032 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1033 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1034 flutter_rust_bridge::for_generated::TaskInfo {
1035 debug_name: "qwen25_3b_config",
1036 port: None,
1037 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1038 },
1039 move || {
1040 let message = unsafe {
1041 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1042 ptr_,
1043 rust_vec_len_,
1044 data_len_,
1045 )
1046 };
1047 let mut deserializer =
1048 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1049 deserializer.end();
1050 transform_result_sse::<_, ()>((move || {
1051 let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_3b_config())?;
1052 Ok(output_ok)
1053 })())
1054 },
1055 )
1056 }
1057 fn wire__crate__api__qwen25_coder_1_5b_config_impl(
1058 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1059 rust_vec_len_: i32,
1060 data_len_: i32,
1061 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1062 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1063 flutter_rust_bridge::for_generated::TaskInfo {
1064 debug_name: "qwen25_coder_1_5b_config",
1065 port: None,
1066 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1067 },
1068 move || {
1069 let message = unsafe {
1070 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1071 ptr_,
1072 rust_vec_len_,
1073 data_len_,
1074 )
1075 };
1076 let mut deserializer =
1077 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1078 deserializer.end();
1079 transform_result_sse::<_, ()>((move || {
1080 let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_coder_1_5b_config())?;
1081 Ok(output_ok)
1082 })())
1083 },
1084 )
1085 }
1086 fn wire__crate__api__qwen25_coder_3b_config_impl(
1087 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1088 rust_vec_len_: i32,
1089 data_len_: i32,
1090 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1091 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1092 flutter_rust_bridge::for_generated::TaskInfo {
1093 debug_name: "qwen25_coder_3b_config",
1094 port: None,
1095 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1096 },
1097 move || {
1098 let message = unsafe {
1099 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1100 ptr_,
1101 rust_vec_len_,
1102 data_len_,
1103 )
1104 };
1105 let mut deserializer =
1106 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1107 deserializer.end();
1108 transform_result_sse::<_, ()>((move || {
1109 let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_coder_3b_config())?;
1110 Ok(output_ok)
1111 })())
1112 },
1113 )
1114 }
1115
1116 // Section: related_funcs
1117
1118 flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
1119 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>
1120 );
1121
1122 // Section: dart2rust
1123
1124 impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
1125 // Codec=Sse (Serialization based), see doc to use other codecs
1126 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1127 let mut inner = <String>::sse_decode(deserializer);
1128 return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
1129 }
1130 }
1131
1132 impl SseDecode for OndeChatEngine {
1133 // Codec=Sse (Serialization based), see doc to use other codecs
1134 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1135 let mut inner = <RustOpaqueMoi<
1136 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
1137 >>::sse_decode(deserializer);
1138 return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
1139 }
1140 }
1141
1142 impl SseDecode
1143 for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>
1144 {
1145 // Codec=Sse (Serialization based), see doc to use other codecs
1146 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1147 let mut inner = <usize>::sse_decode(deserializer);
1148 return decode_rust_opaque_moi(inner);
1149 }
1150 }
1151
1152 impl SseDecode
1153 for StreamSink<crate::api::StreamChunk, flutter_rust_bridge::for_generated::SseCodec>
1154 {
1155 // Codec=Sse (Serialization based), see doc to use other codecs
1156 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1157 let mut inner = <String>::sse_decode(deserializer);
1158 return StreamSink::deserialize(inner);
1159 }
1160 }
1161
1162 impl SseDecode for String {
1163 // Codec=Sse (Serialization based), see doc to use other codecs
1164 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1165 let mut inner = <Vec<u8>>::sse_decode(deserializer);
1166 return String::from_utf8(inner).unwrap();
1167 }
1168 }
1169
1170 impl SseDecode for bool {
1171 // Codec=Sse (Serialization based), see doc to use other codecs
1172 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1173 deserializer.cursor.read_u8().unwrap() != 0
1174 }
1175 }
1176
1177 impl SseDecode for crate::api::ChatMessage {
1178 // Codec=Sse (Serialization based), see doc to use other codecs
1179 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1180 let mut var_role = <crate::api::ChatRole>::sse_decode(deserializer);
1181 let mut var_content = <String>::sse_decode(deserializer);
1182 return crate::api::ChatMessage {
1183 role: var_role,
1184 content: var_content,
1185 };
1186 }
1187 }
1188
1189 impl SseDecode for crate::api::ChatRole {
1190 // Codec=Sse (Serialization based), see doc to use other codecs
1191 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1192 let mut inner = <i32>::sse_decode(deserializer);
1193 return match inner {
1194 0 => crate::api::ChatRole::System,
1195 1 => crate::api::ChatRole::User,
1196 2 => crate::api::ChatRole::Assistant,
1197 _ => unreachable!("Invalid variant for ChatRole: {}", inner),
1198 };
1199 }
1200 }
1201
1202 impl SseDecode for crate::api::EngineInfo {
1203 // Codec=Sse (Serialization based), see doc to use other codecs
1204 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1205 let mut var_status = <crate::api::EngineStatus>::sse_decode(deserializer);
1206 let mut var_modelName = <Option<String>>::sse_decode(deserializer);
1207 let mut var_approxMemory = <Option<String>>::sse_decode(deserializer);
1208 let mut var_historyLength = <u64>::sse_decode(deserializer);
1209 return crate::api::EngineInfo {
1210 status: var_status,
1211 model_name: var_modelName,
1212 approx_memory: var_approxMemory,
1213 history_length: var_historyLength,
1214 };
1215 }
1216 }
1217
1218 impl SseDecode for crate::api::EngineStatus {
1219 // Codec=Sse (Serialization based), see doc to use other codecs
1220 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1221 let mut inner = <i32>::sse_decode(deserializer);
1222 return match inner {
1223 0 => crate::api::EngineStatus::Unloaded,
1224 1 => crate::api::EngineStatus::Loading,
1225 2 => crate::api::EngineStatus::Ready,
1226 3 => crate::api::EngineStatus::Generating,
1227 4 => crate::api::EngineStatus::Error,
1228 _ => unreachable!("Invalid variant for EngineStatus: {}", inner),
1229 };
1230 }
1231 }
1232
1233 impl SseDecode for f32 {
1234 // Codec=Sse (Serialization based), see doc to use other codecs
1235 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1236 deserializer.cursor.read_f32::<NativeEndian>().unwrap()
1237 }
1238 }
1239
1240 impl SseDecode for f64 {
1241 // Codec=Sse (Serialization based), see doc to use other codecs
1242 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1243 deserializer.cursor.read_f64::<NativeEndian>().unwrap()
1244 }
1245 }
1246
1247 impl SseDecode for crate::api::GgufModelConfig {
1248 // Codec=Sse (Serialization based), see doc to use other codecs
1249 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1250 let mut var_modelId = <String>::sse_decode(deserializer);
1251 let mut var_files = <Vec<String>>::sse_decode(deserializer);
1252 let mut var_tokModelId = <Option<String>>::sse_decode(deserializer);
1253 let mut var_displayName = <String>::sse_decode(deserializer);
1254 let mut var_approxMemory = <String>::sse_decode(deserializer);
1255 return crate::api::GgufModelConfig {
1256 model_id: var_modelId,
1257 files: var_files,
1258 tok_model_id: var_tokModelId,
1259 display_name: var_displayName,
1260 approx_memory: var_approxMemory,
1261 };
1262 }
1263 }
1264
1265 impl SseDecode for i32 {
1266 // Codec=Sse (Serialization based), see doc to use other codecs
1267 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1268 deserializer.cursor.read_i32::<NativeEndian>().unwrap()
1269 }
1270 }
1271
1272 impl SseDecode for crate::api::InferenceResult {
1273 // Codec=Sse (Serialization based), see doc to use other codecs
1274 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1275 let mut var_text = <String>::sse_decode(deserializer);
1276 let mut var_durationSecs = <f64>::sse_decode(deserializer);
1277 let mut var_durationDisplay = <String>::sse_decode(deserializer);
1278 let mut var_finishReason = <String>::sse_decode(deserializer);
1279 return crate::api::InferenceResult {
1280 text: var_text,
1281 duration_secs: var_durationSecs,
1282 duration_display: var_durationDisplay,
1283 finish_reason: var_finishReason,
1284 };
1285 }
1286 }
1287
1288 impl SseDecode for Vec<String> {
1289 // Codec=Sse (Serialization based), see doc to use other codecs
1290 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1291 let mut len_ = <i32>::sse_decode(deserializer);
1292 let mut ans_ = Vec::with_capacity(len_ as usize);
1293 for idx_ in 0..len_ {
1294 ans_.push(<String>::sse_decode(deserializer));
1295 }
1296 return ans_;
1297 }
1298 }
1299
1300 impl SseDecode for Vec<crate::api::ChatMessage> {
1301 // Codec=Sse (Serialization based), see doc to use other codecs
1302 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1303 let mut len_ = <i32>::sse_decode(deserializer);
1304 let mut ans_ = Vec::with_capacity(len_ as usize);
1305 for idx_ in 0..len_ {
1306 ans_.push(<crate::api::ChatMessage>::sse_decode(deserializer));
1307 }
1308 return ans_;
1309 }
1310 }
1311
1312 impl SseDecode for Vec<u8> {
1313 // Codec=Sse (Serialization based), see doc to use other codecs
1314 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1315 let mut len_ = <i32>::sse_decode(deserializer);
1316 let mut ans_ = Vec::with_capacity(len_ as usize);
1317 for idx_ in 0..len_ {
1318 ans_.push(<u8>::sse_decode(deserializer));
1319 }
1320 return ans_;
1321 }
1322 }
1323
1324 impl SseDecode for crate::api::OndeError {
1325 // Codec=Sse (Serialization based), see doc to use other codecs
1326 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1327 let mut tag_ = <i32>::sse_decode(deserializer);
1328 match tag_ {
1329 0 => {
1330 return crate::api::OndeError::NoModelLoaded;
1331 }
1332 1 => {
1333 let mut var_modelName = <String>::sse_decode(deserializer);
1334 return crate::api::OndeError::AlreadyLoaded {
1335 model_name: var_modelName,
1336 };
1337 }
1338 2 => {
1339 let mut var_reason = <String>::sse_decode(deserializer);
1340 return crate::api::OndeError::ModelBuild { reason: var_reason };
1341 }
1342 3 => {
1343 let mut var_reason = <String>::sse_decode(deserializer);
1344 return crate::api::OndeError::Inference { reason: var_reason };
1345 }
1346 4 => {
1347 return crate::api::OndeError::Cancelled;
1348 }
1349 5 => {
1350 let mut var_reason = <String>::sse_decode(deserializer);
1351 return crate::api::OndeError::Other { reason: var_reason };
1352 }
1353 _ => {
1354 unimplemented!("");
1355 }
1356 }
1357 }
1358 }
1359
1360 impl SseDecode for Option<String> {
1361 // Codec=Sse (Serialization based), see doc to use other codecs
1362 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1363 if (<bool>::sse_decode(deserializer)) {
1364 return Some(<String>::sse_decode(deserializer));
1365 } else {
1366 return None;
1367 }
1368 }
1369 }
1370
1371 impl SseDecode for Option<f32> {
1372 // Codec=Sse (Serialization based), see doc to use other codecs
1373 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1374 if (<bool>::sse_decode(deserializer)) {
1375 return Some(<f32>::sse_decode(deserializer));
1376 } else {
1377 return None;
1378 }
1379 }
1380 }
1381
1382 impl SseDecode for Option<f64> {
1383 // Codec=Sse (Serialization based), see doc to use other codecs
1384 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1385 if (<bool>::sse_decode(deserializer)) {
1386 return Some(<f64>::sse_decode(deserializer));
1387 } else {
1388 return None;
1389 }
1390 }
1391 }
1392
1393 impl SseDecode for Option<crate::api::SamplingConfig> {
1394 // Codec=Sse (Serialization based), see doc to use other codecs
1395 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1396 if (<bool>::sse_decode(deserializer)) {
1397 return Some(<crate::api::SamplingConfig>::sse_decode(deserializer));
1398 } else {
1399 return None;
1400 }
1401 }
1402 }
1403
1404 impl SseDecode for Option<u64> {
1405 // Codec=Sse (Serialization based), see doc to use other codecs
1406 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1407 if (<bool>::sse_decode(deserializer)) {
1408 return Some(<u64>::sse_decode(deserializer));
1409 } else {
1410 return None;
1411 }
1412 }
1413 }
1414
1415 impl SseDecode for crate::api::SamplingConfig {
1416 // Codec=Sse (Serialization based), see doc to use other codecs
1417 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1418 let mut var_temperature = <Option<f64>>::sse_decode(deserializer);
1419 let mut var_topP = <Option<f64>>::sse_decode(deserializer);
1420 let mut var_topK = <Option<u64>>::sse_decode(deserializer);
1421 let mut var_minP = <Option<f64>>::sse_decode(deserializer);
1422 let mut var_maxTokens = <Option<u64>>::sse_decode(deserializer);
1423 let mut var_frequencyPenalty = <Option<f32>>::sse_decode(deserializer);
1424 let mut var_presencePenalty = <Option<f32>>::sse_decode(deserializer);
1425 return crate::api::SamplingConfig {
1426 temperature: var_temperature,
1427 top_p: var_topP,
1428 top_k: var_topK,
1429 min_p: var_minP,
1430 max_tokens: var_maxTokens,
1431 frequency_penalty: var_frequencyPenalty,
1432 presence_penalty: var_presencePenalty,
1433 };
1434 }
1435 }
1436
1437 impl SseDecode for crate::api::StreamChunk {
1438 // Codec=Sse (Serialization based), see doc to use other codecs
1439 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1440 let mut var_delta = <String>::sse_decode(deserializer);
1441 let mut var_done = <bool>::sse_decode(deserializer);
1442 let mut var_finishReason = <Option<String>>::sse_decode(deserializer);
1443 return crate::api::StreamChunk {
1444 delta: var_delta,
1445 done: var_done,
1446 finish_reason: var_finishReason,
1447 };
1448 }
1449 }
1450
1451 impl SseDecode for u64 {
1452 // Codec=Sse (Serialization based), see doc to use other codecs
1453 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1454 deserializer.cursor.read_u64::<NativeEndian>().unwrap()
1455 }
1456 }
1457
1458 impl SseDecode for u8 {
1459 // Codec=Sse (Serialization based), see doc to use other codecs
1460 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1461 deserializer.cursor.read_u8().unwrap()
1462 }
1463 }
1464
1465 impl SseDecode for () {
1466 // Codec=Sse (Serialization based), see doc to use other codecs
1467 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
1468 }
1469
1470 impl SseDecode for usize {
1471 // Codec=Sse (Serialization based), see doc to use other codecs
1472 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1473 deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
1474 }
1475 }
1476
1477 fn pde_ffi_dispatcher_primary_impl(
1478 func_id: i32,
1479 port: flutter_rust_bridge::for_generated::MessagePort,
1480 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1481 rust_vec_len: i32,
1482 data_len: i32,
1483 ) {
1484 // Codec=Pde (Serialization + dispatch), see doc to use other codecs
1485 match func_id {
1486 1 => wire__crate__api__OndeChatEngine_clear_history_impl(port, ptr, rust_vec_len, data_len),
1487 2 => wire__crate__api__OndeChatEngine_clear_system_prompt_impl(
1488 port,
1489 ptr,
1490 rust_vec_len,
1491 data_len,
1492 ),
1493 3 => wire__crate__api__OndeChatEngine_generate_impl(port, ptr, rust_vec_len, data_len),
1494 4 => wire__crate__api__OndeChatEngine_history_impl(port, ptr, rust_vec_len, data_len),
1495 5 => wire__crate__api__OndeChatEngine_info_impl(port, ptr, rust_vec_len, data_len),
1496 6 => wire__crate__api__OndeChatEngine_is_loaded_impl(port, ptr, rust_vec_len, data_len),
1497 7 => {
1498 wire__crate__api__OndeChatEngine_load_gguf_model_impl(port, ptr, rust_vec_len, data_len)
1499 }
1500 9 => wire__crate__api__OndeChatEngine_push_history_impl(port, ptr, rust_vec_len, data_len),
1501 10 => wire__crate__api__OndeChatEngine_send_message_impl(port, ptr, rust_vec_len, data_len),
1502 11 => wire__crate__api__OndeChatEngine_set_sampling_impl(port, ptr, rust_vec_len, data_len),
1503 12 => wire__crate__api__OndeChatEngine_set_system_prompt_impl(
1504 port,
1505 ptr,
1506 rust_vec_len,
1507 data_len,
1508 ),
1509 13 => {
1510 wire__crate__api__OndeChatEngine_stream_message_impl(port, ptr, rust_vec_len, data_len)
1511 }
1512 14 => wire__crate__api__OndeChatEngine_unload_model_impl(port, ptr, rust_vec_len, data_len),
1513 _ => unreachable!(),
1514 }
1515 }
1516
1517 fn pde_ffi_dispatcher_sync_impl(
1518 func_id: i32,
1519 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1520 rust_vec_len: i32,
1521 data_len: i32,
1522 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1523 // Codec=Pde (Serialization + dispatch), see doc to use other codecs
1524 match func_id {
1525 8 => wire__crate__api__OndeChatEngine_new_impl(ptr, rust_vec_len, data_len),
1526 15 => wire__crate__api__configure_cache_dir_impl(ptr, rust_vec_len, data_len),
1527 16 => wire__crate__api__default_model_config_impl(ptr, rust_vec_len, data_len),
1528 17 => wire__crate__api__default_sampling_config_impl(ptr, rust_vec_len, data_len),
1529 18 => wire__crate__api__deterministic_sampling_config_impl(ptr, rust_vec_len, data_len),
1530 19 => wire__crate__api__mobile_sampling_config_impl(ptr, rust_vec_len, data_len),
1531 20 => wire__crate__api__qwen25_1_5b_config_impl(ptr, rust_vec_len, data_len),
1532 21 => wire__crate__api__qwen25_3b_config_impl(ptr, rust_vec_len, data_len),
1533 22 => wire__crate__api__qwen25_coder_1_5b_config_impl(ptr, rust_vec_len, data_len),
1534 23 => wire__crate__api__qwen25_coder_3b_config_impl(ptr, rust_vec_len, data_len),
1535 _ => unreachable!(),
1536 }
1537 }
1538
1539 // Section: rust2dart
1540
1541 // Codec=Dco (DartCObject based), see doc to use other codecs
1542 impl flutter_rust_bridge::IntoDart for FrbWrapper<OndeChatEngine> {
1543 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1544 flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0)
1545 .into_dart()
1546 }
1547 }
1548 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<OndeChatEngine> {}
1549
1550 impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<OndeChatEngine>> for OndeChatEngine {
1551 fn into_into_dart(self) -> FrbWrapper<OndeChatEngine> {
1552 self.into()
1553 }
1554 }
1555
1556 // Codec=Dco (DartCObject based), see doc to use other codecs
1557 impl flutter_rust_bridge::IntoDart for crate::api::ChatMessage {
1558 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1559 [
1560 self.role.into_into_dart().into_dart(),
1561 self.content.into_into_dart().into_dart(),
1562 ]
1563 .into_dart()
1564 }
1565 }
1566 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ChatMessage {}
1567 impl flutter_rust_bridge::IntoIntoDart<crate::api::ChatMessage> for crate::api::ChatMessage {
1568 fn into_into_dart(self) -> crate::api::ChatMessage {
1569 self
1570 }
1571 }
1572 // Codec=Dco (DartCObject based), see doc to use other codecs
1573 impl flutter_rust_bridge::IntoDart for crate::api::ChatRole {
1574 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1575 match self {
1576 Self::System => 0.into_dart(),
1577 Self::User => 1.into_dart(),
1578 Self::Assistant => 2.into_dart(),
1579 _ => unreachable!(),
1580 }
1581 }
1582 }
1583 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ChatRole {}
1584 impl flutter_rust_bridge::IntoIntoDart<crate::api::ChatRole> for crate::api::ChatRole {
1585 fn into_into_dart(self) -> crate::api::ChatRole {
1586 self
1587 }
1588 }
1589 // Codec=Dco (DartCObject based), see doc to use other codecs
1590 impl flutter_rust_bridge::IntoDart for crate::api::EngineInfo {
1591 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1592 [
1593 self.status.into_into_dart().into_dart(),
1594 self.model_name.into_into_dart().into_dart(),
1595 self.approx_memory.into_into_dart().into_dart(),
1596 self.history_length.into_into_dart().into_dart(),
1597 ]
1598 .into_dart()
1599 }
1600 }
1601 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::EngineInfo {}
1602 impl flutter_rust_bridge::IntoIntoDart<crate::api::EngineInfo> for crate::api::EngineInfo {
1603 fn into_into_dart(self) -> crate::api::EngineInfo {
1604 self
1605 }
1606 }
1607 // Codec=Dco (DartCObject based), see doc to use other codecs
1608 impl flutter_rust_bridge::IntoDart for crate::api::EngineStatus {
1609 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1610 match self {
1611 Self::Unloaded => 0.into_dart(),
1612 Self::Loading => 1.into_dart(),
1613 Self::Ready => 2.into_dart(),
1614 Self::Generating => 3.into_dart(),
1615 Self::Error => 4.into_dart(),
1616 _ => unreachable!(),
1617 }
1618 }
1619 }
1620 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::EngineStatus {}
1621 impl flutter_rust_bridge::IntoIntoDart<crate::api::EngineStatus> for crate::api::EngineStatus {
1622 fn into_into_dart(self) -> crate::api::EngineStatus {
1623 self
1624 }
1625 }
1626 // Codec=Dco (DartCObject based), see doc to use other codecs
1627 impl flutter_rust_bridge::IntoDart for crate::api::GgufModelConfig {
1628 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1629 [
1630 self.model_id.into_into_dart().into_dart(),
1631 self.files.into_into_dart().into_dart(),
1632 self.tok_model_id.into_into_dart().into_dart(),
1633 self.display_name.into_into_dart().into_dart(),
1634 self.approx_memory.into_into_dart().into_dart(),
1635 ]
1636 .into_dart()
1637 }
1638 }
1639 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::GgufModelConfig {}
1640 impl flutter_rust_bridge::IntoIntoDart<crate::api::GgufModelConfig>
1641 for crate::api::GgufModelConfig
1642 {
1643 fn into_into_dart(self) -> crate::api::GgufModelConfig {
1644 self
1645 }
1646 }
1647 // Codec=Dco (DartCObject based), see doc to use other codecs
1648 impl flutter_rust_bridge::IntoDart for crate::api::InferenceResult {
1649 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1650 [
1651 self.text.into_into_dart().into_dart(),
1652 self.duration_secs.into_into_dart().into_dart(),
1653 self.duration_display.into_into_dart().into_dart(),
1654 self.finish_reason.into_into_dart().into_dart(),
1655 ]
1656 .into_dart()
1657 }
1658 }
1659 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::InferenceResult {}
1660 impl flutter_rust_bridge::IntoIntoDart<crate::api::InferenceResult>
1661 for crate::api::InferenceResult
1662 {
1663 fn into_into_dart(self) -> crate::api::InferenceResult {
1664 self
1665 }
1666 }
1667 // Codec=Dco (DartCObject based), see doc to use other codecs
1668 impl flutter_rust_bridge::IntoDart for crate::api::OndeError {
1669 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1670 match self {
1671 crate::api::OndeError::NoModelLoaded => [0.into_dart()].into_dart(),
1672 crate::api::OndeError::AlreadyLoaded { model_name } => {
1673 [1.into_dart(), model_name.into_into_dart().into_dart()].into_dart()
1674 }
1675 crate::api::OndeError::ModelBuild { reason } => {
1676 [2.into_dart(), reason.into_into_dart().into_dart()].into_dart()
1677 }
1678 crate::api::OndeError::Inference { reason } => {
1679 [3.into_dart(), reason.into_into_dart().into_dart()].into_dart()
1680 }
1681 crate::api::OndeError::Cancelled => [4.into_dart()].into_dart(),
1682 crate::api::OndeError::Other { reason } => {
1683 [5.into_dart(), reason.into_into_dart().into_dart()].into_dart()
1684 }
1685 _ => {
1686 unimplemented!("");
1687 }
1688 }
1689 }
1690 }
1691 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::OndeError {}
1692 impl flutter_rust_bridge::IntoIntoDart<crate::api::OndeError> for crate::api::OndeError {
1693 fn into_into_dart(self) -> crate::api::OndeError {
1694 self
1695 }
1696 }
1697 // Codec=Dco (DartCObject based), see doc to use other codecs
1698 impl flutter_rust_bridge::IntoDart for crate::api::SamplingConfig {
1699 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1700 [
1701 self.temperature.into_into_dart().into_dart(),
1702 self.top_p.into_into_dart().into_dart(),
1703 self.top_k.into_into_dart().into_dart(),
1704 self.min_p.into_into_dart().into_dart(),
1705 self.max_tokens.into_into_dart().into_dart(),
1706 self.frequency_penalty.into_into_dart().into_dart(),
1707 self.presence_penalty.into_into_dart().into_dart(),
1708 ]
1709 .into_dart()
1710 }
1711 }
1712 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::SamplingConfig {}
1713 impl flutter_rust_bridge::IntoIntoDart<crate::api::SamplingConfig> for crate::api::SamplingConfig {
1714 fn into_into_dart(self) -> crate::api::SamplingConfig {
1715 self
1716 }
1717 }
1718 // Codec=Dco (DartCObject based), see doc to use other codecs
1719 impl flutter_rust_bridge::IntoDart for crate::api::StreamChunk {
1720 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1721 [
1722 self.delta.into_into_dart().into_dart(),
1723 self.done.into_into_dart().into_dart(),
1724 self.finish_reason.into_into_dart().into_dart(),
1725 ]
1726 .into_dart()
1727 }
1728 }
1729 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::StreamChunk {}
1730 impl flutter_rust_bridge::IntoIntoDart<crate::api::StreamChunk> for crate::api::StreamChunk {
1731 fn into_into_dart(self) -> crate::api::StreamChunk {
1732 self
1733 }
1734 }
1735
1736 impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
1737 // Codec=Sse (Serialization based), see doc to use other codecs
1738 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1739 <String>::sse_encode(format!("{:?}", self), serializer);
1740 }
1741 }
1742
1743 impl SseEncode for OndeChatEngine {
1744 // Codec=Sse (Serialization based), see doc to use other codecs
1745 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1746 <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
1747 }
1748 }
1749
1750 impl SseEncode
1751 for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>
1752 {
1753 // Codec=Sse (Serialization based), see doc to use other codecs
1754 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1755 let (ptr, size) = self.sse_encode_raw();
1756 <usize>::sse_encode(ptr, serializer);
1757 <i32>::sse_encode(size, serializer);
1758 }
1759 }
1760
1761 impl SseEncode
1762 for StreamSink<crate::api::StreamChunk, flutter_rust_bridge::for_generated::SseCodec>
1763 {
1764 // Codec=Sse (Serialization based), see doc to use other codecs
1765 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1766 unimplemented!("")
1767 }
1768 }
1769
1770 impl SseEncode for String {
1771 // Codec=Sse (Serialization based), see doc to use other codecs
1772 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1773 <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
1774 }
1775 }
1776
1777 impl SseEncode for bool {
1778 // Codec=Sse (Serialization based), see doc to use other codecs
1779 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1780 serializer.cursor.write_u8(self as _).unwrap();
1781 }
1782 }
1783
1784 impl SseEncode for crate::api::ChatMessage {
1785 // Codec=Sse (Serialization based), see doc to use other codecs
1786 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1787 <crate::api::ChatRole>::sse_encode(self.role, serializer);
1788 <String>::sse_encode(self.content, serializer);
1789 }
1790 }
1791
1792 impl SseEncode for crate::api::ChatRole {
1793 // Codec=Sse (Serialization based), see doc to use other codecs
1794 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1795 <i32>::sse_encode(
1796 match self {
1797 crate::api::ChatRole::System => 0,
1798 crate::api::ChatRole::User => 1,
1799 crate::api::ChatRole::Assistant => 2,
1800 _ => {
1801 unimplemented!("");
1802 }
1803 },
1804 serializer,
1805 );
1806 }
1807 }
1808
1809 impl SseEncode for crate::api::EngineInfo {
1810 // Codec=Sse (Serialization based), see doc to use other codecs
1811 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1812 <crate::api::EngineStatus>::sse_encode(self.status, serializer);
1813 <Option<String>>::sse_encode(self.model_name, serializer);
1814 <Option<String>>::sse_encode(self.approx_memory, serializer);
1815 <u64>::sse_encode(self.history_length, serializer);
1816 }
1817 }
1818
1819 impl SseEncode for crate::api::EngineStatus {
1820 // Codec=Sse (Serialization based), see doc to use other codecs
1821 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1822 <i32>::sse_encode(
1823 match self {
1824 crate::api::EngineStatus::Unloaded => 0,
1825 crate::api::EngineStatus::Loading => 1,
1826 crate::api::EngineStatus::Ready => 2,
1827 crate::api::EngineStatus::Generating => 3,
1828 crate::api::EngineStatus::Error => 4,
1829 _ => {
1830 unimplemented!("");
1831 }
1832 },
1833 serializer,
1834 );
1835 }
1836 }
1837
1838 impl SseEncode for f32 {
1839 // Codec=Sse (Serialization based), see doc to use other codecs
1840 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1841 serializer.cursor.write_f32::<NativeEndian>(self).unwrap();
1842 }
1843 }
1844
1845 impl SseEncode for f64 {
1846 // Codec=Sse (Serialization based), see doc to use other codecs
1847 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1848 serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
1849 }
1850 }
1851
1852 impl SseEncode for crate::api::GgufModelConfig {
1853 // Codec=Sse (Serialization based), see doc to use other codecs
1854 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1855 <String>::sse_encode(self.model_id, serializer);
1856 <Vec<String>>::sse_encode(self.files, serializer);
1857 <Option<String>>::sse_encode(self.tok_model_id, serializer);
1858 <String>::sse_encode(self.display_name, serializer);
1859 <String>::sse_encode(self.approx_memory, serializer);
1860 }
1861 }
1862
1863 impl SseEncode for i32 {
1864 // Codec=Sse (Serialization based), see doc to use other codecs
1865 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1866 serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
1867 }
1868 }
1869
1870 impl SseEncode for crate::api::InferenceResult {
1871 // Codec=Sse (Serialization based), see doc to use other codecs
1872 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1873 <String>::sse_encode(self.text, serializer);
1874 <f64>::sse_encode(self.duration_secs, serializer);
1875 <String>::sse_encode(self.duration_display, serializer);
1876 <String>::sse_encode(self.finish_reason, serializer);
1877 }
1878 }
1879
1880 impl SseEncode for Vec<String> {
1881 // Codec=Sse (Serialization based), see doc to use other codecs
1882 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1883 <i32>::sse_encode(self.len() as _, serializer);
1884 for item in self {
1885 <String>::sse_encode(item, serializer);
1886 }
1887 }
1888 }
1889
1890 impl SseEncode for Vec<crate::api::ChatMessage> {
1891 // Codec=Sse (Serialization based), see doc to use other codecs
1892 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1893 <i32>::sse_encode(self.len() as _, serializer);
1894 for item in self {
1895 <crate::api::ChatMessage>::sse_encode(item, serializer);
1896 }
1897 }
1898 }
1899
1900 impl SseEncode for Vec<u8> {
1901 // Codec=Sse (Serialization based), see doc to use other codecs
1902 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1903 <i32>::sse_encode(self.len() as _, serializer);
1904 for item in self {
1905 <u8>::sse_encode(item, serializer);
1906 }
1907 }
1908 }
1909
1910 impl SseEncode for crate::api::OndeError {
1911 // Codec=Sse (Serialization based), see doc to use other codecs
1912 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1913 match self {
1914 crate::api::OndeError::NoModelLoaded => {
1915 <i32>::sse_encode(0, serializer);
1916 }
1917 crate::api::OndeError::AlreadyLoaded { model_name } => {
1918 <i32>::sse_encode(1, serializer);
1919 <String>::sse_encode(model_name, serializer);
1920 }
1921 crate::api::OndeError::ModelBuild { reason } => {
1922 <i32>::sse_encode(2, serializer);
1923 <String>::sse_encode(reason, serializer);
1924 }
1925 crate::api::OndeError::Inference { reason } => {
1926 <i32>::sse_encode(3, serializer);
1927 <String>::sse_encode(reason, serializer);
1928 }
1929 crate::api::OndeError::Cancelled => {
1930 <i32>::sse_encode(4, serializer);
1931 }
1932 crate::api::OndeError::Other { reason } => {
1933 <i32>::sse_encode(5, serializer);
1934 <String>::sse_encode(reason, serializer);
1935 }
1936 _ => {
1937 unimplemented!("");
1938 }
1939 }
1940 }
1941 }
1942
1943 impl SseEncode for Option<String> {
1944 // Codec=Sse (Serialization based), see doc to use other codecs
1945 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1946 <bool>::sse_encode(self.is_some(), serializer);
1947 if let Some(value) = self {
1948 <String>::sse_encode(value, serializer);
1949 }
1950 }
1951 }
1952
1953 impl SseEncode for Option<f32> {
1954 // Codec=Sse (Serialization based), see doc to use other codecs
1955 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1956 <bool>::sse_encode(self.is_some(), serializer);
1957 if let Some(value) = self {
1958 <f32>::sse_encode(value, serializer);
1959 }
1960 }
1961 }
1962
1963 impl SseEncode for Option<f64> {
1964 // Codec=Sse (Serialization based), see doc to use other codecs
1965 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1966 <bool>::sse_encode(self.is_some(), serializer);
1967 if let Some(value) = self {
1968 <f64>::sse_encode(value, serializer);
1969 }
1970 }
1971 }
1972
1973 impl SseEncode for Option<crate::api::SamplingConfig> {
1974 // Codec=Sse (Serialization based), see doc to use other codecs
1975 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1976 <bool>::sse_encode(self.is_some(), serializer);
1977 if let Some(value) = self {
1978 <crate::api::SamplingConfig>::sse_encode(value, serializer);
1979 }
1980 }
1981 }
1982
1983 impl SseEncode for Option<u64> {
1984 // Codec=Sse (Serialization based), see doc to use other codecs
1985 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1986 <bool>::sse_encode(self.is_some(), serializer);
1987 if let Some(value) = self {
1988 <u64>::sse_encode(value, serializer);
1989 }
1990 }
1991 }
1992
1993 impl SseEncode for crate::api::SamplingConfig {
1994 // Codec=Sse (Serialization based), see doc to use other codecs
1995 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1996 <Option<f64>>::sse_encode(self.temperature, serializer);
1997 <Option<f64>>::sse_encode(self.top_p, serializer);
1998 <Option<u64>>::sse_encode(self.top_k, serializer);
1999 <Option<f64>>::sse_encode(self.min_p, serializer);
2000 <Option<u64>>::sse_encode(self.max_tokens, serializer);
2001 <Option<f32>>::sse_encode(self.frequency_penalty, serializer);
2002 <Option<f32>>::sse_encode(self.presence_penalty, serializer);
2003 }
2004 }
2005
2006 impl SseEncode for crate::api::StreamChunk {
2007 // Codec=Sse (Serialization based), see doc to use other codecs
2008 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2009 <String>::sse_encode(self.delta, serializer);
2010 <bool>::sse_encode(self.done, serializer);
2011 <Option<String>>::sse_encode(self.finish_reason, serializer);
2012 }
2013 }
2014
2015 impl SseEncode for u64 {
2016 // Codec=Sse (Serialization based), see doc to use other codecs
2017 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2018 serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
2019 }
2020 }
2021
2022 impl SseEncode for u8 {
2023 // Codec=Sse (Serialization based), see doc to use other codecs
2024 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2025 serializer.cursor.write_u8(self).unwrap();
2026 }
2027 }
2028
2029 impl SseEncode for () {
2030 // Codec=Sse (Serialization based), see doc to use other codecs
2031 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
2032 }
2033
2034 impl SseEncode for usize {
2035 // Codec=Sse (Serialization based), see doc to use other codecs
2036 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2037 serializer
2038 .cursor
2039 .write_u64::<NativeEndian>(self as _)
2040 .unwrap();
2041 }
2042 }
2043
2044 #[cfg(not(target_family = "wasm"))]
2045 mod io {
2046 // This file is automatically generated, so please do not edit it.
2047 // @generated by `flutter_rust_bridge`@ 2.12.0.
2048
2049 // Section: imports
2050
2051 use super::*;
2052 use crate::api::*;
2053 use flutter_rust_bridge::for_generated::byteorder::{
2054 NativeEndian, ReadBytesExt, WriteBytesExt,
2055 };
2056 use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
2057 use flutter_rust_bridge::{Handler, IntoIntoDart};
2058
2059 // Section: boilerplate
2060
2061 flutter_rust_bridge::frb_generated_boilerplate_io!();
2062
2063 #[unsafe(no_mangle)]
2064 pub extern "C" fn frbgen_onde_inference_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOndeChatEngine(
2065 ptr: *const std::ffi::c_void,
2066 ) {
2067 MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>::increment_strong_count(ptr as _);
2068 }
2069
2070 #[unsafe(no_mangle)]
2071 pub extern "C" fn frbgen_onde_inference_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOndeChatEngine(
2072 ptr: *const std::ffi::c_void,
2073 ) {
2074 MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>::decrement_strong_count(ptr as _);
2075 }
2076 }
2077 #[cfg(not(target_family = "wasm"))]
2078 pub use io::*;