@ondeinference / onde
Code Commits Issues Pulls Cloud Agent CI/CD
copilot/fix-onde-npm-sdk-v1-1-2-release
copilot/assess-inference-engine-complexity copilot/fix-onde-npm-sdk-v1-1-2-release development feature/diffusion-vision main
rs 2,216 lines 90.4 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 = -467241906;
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_assigned_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_assigned_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_app_id = <String>::sse_decode(&mut deserializer);
423 let api_app_secret = <String>::sse_decode(&mut deserializer);
424 let api_system_prompt = <Option<String>>::sse_decode(&mut deserializer);
425 let api_sampling = <Option<crate::api::SamplingConfig>>::sse_decode(&mut deserializer);
426 deserializer.end();
427 move |context| async move {
428 transform_result_sse::<_, crate::api::OndeError>(
429 (move || async move {
430 let mut api_that_guard = None;
431 let decode_indices_ =
432 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
433 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
434 &api_that, 0, false,
435 )],
436 );
437 for i in decode_indices_ {
438 match i {
439 0 => {
440 api_that_guard =
441 Some(api_that.lockable_decode_async_ref().await)
442 }
443 _ => unreachable!(),
444 }
445 }
446 let api_that_guard = api_that_guard.unwrap();
447 let output_ok = crate::api::OndeChatEngine::load_assigned_model(
448 &*api_that_guard,
449 api_app_id,
450 api_app_secret,
451 api_system_prompt,
452 api_sampling,
453 )
454 .await?;
455 Ok(output_ok)
456 })()
457 .await,
458 )
459 }
460 },
461 )
462 }
463 fn wire__crate__api__OndeChatEngine_load_gguf_model_impl(
464 port_: flutter_rust_bridge::for_generated::MessagePort,
465 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
466 rust_vec_len_: i32,
467 data_len_: i32,
468 ) {
469 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
470 flutter_rust_bridge::for_generated::TaskInfo {
471 debug_name: "OndeChatEngine_load_gguf_model",
472 port: Some(port_),
473 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
474 },
475 move || {
476 let message = unsafe {
477 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
478 ptr_,
479 rust_vec_len_,
480 data_len_,
481 )
482 };
483 let mut deserializer =
484 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
485 let api_that = <RustOpaqueMoi<
486 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
487 >>::sse_decode(&mut deserializer);
488 let api_config = <crate::api::GgufModelConfig>::sse_decode(&mut deserializer);
489 let api_system_prompt = <Option<String>>::sse_decode(&mut deserializer);
490 let api_sampling = <Option<crate::api::SamplingConfig>>::sse_decode(&mut deserializer);
491 deserializer.end();
492 move |context| async move {
493 transform_result_sse::<_, crate::api::OndeError>(
494 (move || async move {
495 let mut api_that_guard = None;
496 let decode_indices_ =
497 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
498 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
499 &api_that, 0, false,
500 )],
501 );
502 for i in decode_indices_ {
503 match i {
504 0 => {
505 api_that_guard =
506 Some(api_that.lockable_decode_async_ref().await)
507 }
508 _ => unreachable!(),
509 }
510 }
511 let api_that_guard = api_that_guard.unwrap();
512 let output_ok = crate::api::OndeChatEngine::load_gguf_model(
513 &*api_that_guard,
514 api_config,
515 api_system_prompt,
516 api_sampling,
517 )
518 .await?;
519 Ok(output_ok)
520 })()
521 .await,
522 )
523 }
524 },
525 )
526 }
527 fn wire__crate__api__OndeChatEngine_new_impl(
528 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
529 rust_vec_len_: i32,
530 data_len_: i32,
531 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
532 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
533 flutter_rust_bridge::for_generated::TaskInfo {
534 debug_name: "OndeChatEngine_new",
535 port: None,
536 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
537 },
538 move || {
539 let message = unsafe {
540 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
541 ptr_,
542 rust_vec_len_,
543 data_len_,
544 )
545 };
546 let mut deserializer =
547 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
548 deserializer.end();
549 transform_result_sse::<_, ()>((move || {
550 let output_ok = Result::<_, ()>::Ok(crate::api::OndeChatEngine::new())?;
551 Ok(output_ok)
552 })())
553 },
554 )
555 }
556 fn wire__crate__api__OndeChatEngine_push_history_impl(
557 port_: flutter_rust_bridge::for_generated::MessagePort,
558 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
559 rust_vec_len_: i32,
560 data_len_: i32,
561 ) {
562 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
563 flutter_rust_bridge::for_generated::TaskInfo {
564 debug_name: "OndeChatEngine_push_history",
565 port: Some(port_),
566 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
567 },
568 move || {
569 let message = unsafe {
570 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
571 ptr_,
572 rust_vec_len_,
573 data_len_,
574 )
575 };
576 let mut deserializer =
577 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
578 let api_that = <RustOpaqueMoi<
579 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
580 >>::sse_decode(&mut deserializer);
581 let api_message = <crate::api::ChatMessage>::sse_decode(&mut deserializer);
582 deserializer.end();
583 move |context| async move {
584 transform_result_sse::<_, ()>(
585 (move || async move {
586 let mut api_that_guard = None;
587 let decode_indices_ =
588 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
589 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
590 &api_that, 0, false,
591 )],
592 );
593 for i in decode_indices_ {
594 match i {
595 0 => {
596 api_that_guard =
597 Some(api_that.lockable_decode_async_ref().await)
598 }
599 _ => unreachable!(),
600 }
601 }
602 let api_that_guard = api_that_guard.unwrap();
603 let output_ok = Result::<_, ()>::Ok({
604 crate::api::OndeChatEngine::push_history(&*api_that_guard, api_message)
605 .await;
606 })?;
607 Ok(output_ok)
608 })()
609 .await,
610 )
611 }
612 },
613 )
614 }
615 fn wire__crate__api__OndeChatEngine_send_message_impl(
616 port_: flutter_rust_bridge::for_generated::MessagePort,
617 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
618 rust_vec_len_: i32,
619 data_len_: i32,
620 ) {
621 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
622 flutter_rust_bridge::for_generated::TaskInfo {
623 debug_name: "OndeChatEngine_send_message",
624 port: Some(port_),
625 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
626 },
627 move || {
628 let message = unsafe {
629 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
630 ptr_,
631 rust_vec_len_,
632 data_len_,
633 )
634 };
635 let mut deserializer =
636 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
637 let api_that = <RustOpaqueMoi<
638 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
639 >>::sse_decode(&mut deserializer);
640 let api_message = <String>::sse_decode(&mut deserializer);
641 deserializer.end();
642 move |context| async move {
643 transform_result_sse::<_, crate::api::OndeError>(
644 (move || async move {
645 let mut api_that_guard = None;
646 let decode_indices_ =
647 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
648 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
649 &api_that, 0, false,
650 )],
651 );
652 for i in decode_indices_ {
653 match i {
654 0 => {
655 api_that_guard =
656 Some(api_that.lockable_decode_async_ref().await)
657 }
658 _ => unreachable!(),
659 }
660 }
661 let api_that_guard = api_that_guard.unwrap();
662 let output_ok =
663 crate::api::OndeChatEngine::send_message(&*api_that_guard, api_message)
664 .await?;
665 Ok(output_ok)
666 })()
667 .await,
668 )
669 }
670 },
671 )
672 }
673 fn wire__crate__api__OndeChatEngine_set_sampling_impl(
674 port_: flutter_rust_bridge::for_generated::MessagePort,
675 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
676 rust_vec_len_: i32,
677 data_len_: i32,
678 ) {
679 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
680 flutter_rust_bridge::for_generated::TaskInfo {
681 debug_name: "OndeChatEngine_set_sampling",
682 port: Some(port_),
683 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
684 },
685 move || {
686 let message = unsafe {
687 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
688 ptr_,
689 rust_vec_len_,
690 data_len_,
691 )
692 };
693 let mut deserializer =
694 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
695 let api_that = <RustOpaqueMoi<
696 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
697 >>::sse_decode(&mut deserializer);
698 let api_sampling = <crate::api::SamplingConfig>::sse_decode(&mut deserializer);
699 deserializer.end();
700 move |context| async move {
701 transform_result_sse::<_, ()>(
702 (move || async move {
703 let mut api_that_guard = None;
704 let decode_indices_ =
705 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
706 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
707 &api_that, 0, false,
708 )],
709 );
710 for i in decode_indices_ {
711 match i {
712 0 => {
713 api_that_guard =
714 Some(api_that.lockable_decode_async_ref().await)
715 }
716 _ => unreachable!(),
717 }
718 }
719 let api_that_guard = api_that_guard.unwrap();
720 let output_ok = Result::<_, ()>::Ok({
721 crate::api::OndeChatEngine::set_sampling(
722 &*api_that_guard,
723 api_sampling,
724 )
725 .await;
726 })?;
727 Ok(output_ok)
728 })()
729 .await,
730 )
731 }
732 },
733 )
734 }
735 fn wire__crate__api__OndeChatEngine_set_system_prompt_impl(
736 port_: flutter_rust_bridge::for_generated::MessagePort,
737 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
738 rust_vec_len_: i32,
739 data_len_: i32,
740 ) {
741 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
742 flutter_rust_bridge::for_generated::TaskInfo {
743 debug_name: "OndeChatEngine_set_system_prompt",
744 port: Some(port_),
745 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
746 },
747 move || {
748 let message = unsafe {
749 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
750 ptr_,
751 rust_vec_len_,
752 data_len_,
753 )
754 };
755 let mut deserializer =
756 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
757 let api_that = <RustOpaqueMoi<
758 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
759 >>::sse_decode(&mut deserializer);
760 let api_prompt = <String>::sse_decode(&mut deserializer);
761 deserializer.end();
762 move |context| async move {
763 transform_result_sse::<_, ()>(
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 = Result::<_, ()>::Ok({
783 crate::api::OndeChatEngine::set_system_prompt(
784 &*api_that_guard,
785 api_prompt,
786 )
787 .await;
788 })?;
789 Ok(output_ok)
790 })()
791 .await,
792 )
793 }
794 },
795 )
796 }
797 fn wire__crate__api__OndeChatEngine_stream_message_impl(
798 port_: flutter_rust_bridge::for_generated::MessagePort,
799 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
800 rust_vec_len_: i32,
801 data_len_: i32,
802 ) {
803 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
804 flutter_rust_bridge::for_generated::TaskInfo {
805 debug_name: "OndeChatEngine_stream_message",
806 port: Some(port_),
807 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
808 },
809 move || {
810 let message = unsafe {
811 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
812 ptr_,
813 rust_vec_len_,
814 data_len_,
815 )
816 };
817 let mut deserializer =
818 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
819 let api_that = <RustOpaqueMoi<
820 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
821 >>::sse_decode(&mut deserializer);
822 let api_message = <String>::sse_decode(&mut deserializer);
823 let api_sink = <StreamSink<
824 crate::api::StreamChunk,
825 flutter_rust_bridge::for_generated::SseCodec,
826 >>::sse_decode(&mut deserializer);
827 deserializer.end();
828 move |context| async move {
829 transform_result_sse::<_, crate::api::OndeError>(
830 (move || async move {
831 let mut api_that_guard = None;
832 let decode_indices_ =
833 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
834 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
835 &api_that, 0, false,
836 )],
837 );
838 for i in decode_indices_ {
839 match i {
840 0 => {
841 api_that_guard =
842 Some(api_that.lockable_decode_async_ref().await)
843 }
844 _ => unreachable!(),
845 }
846 }
847 let api_that_guard = api_that_guard.unwrap();
848 let output_ok = crate::api::OndeChatEngine::stream_message(
849 &*api_that_guard,
850 api_message,
851 api_sink,
852 )
853 .await?;
854 Ok(output_ok)
855 })()
856 .await,
857 )
858 }
859 },
860 )
861 }
862 fn wire__crate__api__OndeChatEngine_unload_model_impl(
863 port_: flutter_rust_bridge::for_generated::MessagePort,
864 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
865 rust_vec_len_: i32,
866 data_len_: i32,
867 ) {
868 FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
869 flutter_rust_bridge::for_generated::TaskInfo {
870 debug_name: "OndeChatEngine_unload_model",
871 port: Some(port_),
872 mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
873 },
874 move || {
875 let message = unsafe {
876 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
877 ptr_,
878 rust_vec_len_,
879 data_len_,
880 )
881 };
882 let mut deserializer =
883 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
884 let api_that = <RustOpaqueMoi<
885 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
886 >>::sse_decode(&mut deserializer);
887 deserializer.end();
888 move |context| async move {
889 transform_result_sse::<_, ()>(
890 (move || async move {
891 let mut api_that_guard = None;
892 let decode_indices_ =
893 flutter_rust_bridge::for_generated::lockable_compute_decode_order(
894 vec![flutter_rust_bridge::for_generated::LockableOrderInfo::new(
895 &api_that, 0, false,
896 )],
897 );
898 for i in decode_indices_ {
899 match i {
900 0 => {
901 api_that_guard =
902 Some(api_that.lockable_decode_async_ref().await)
903 }
904 _ => unreachable!(),
905 }
906 }
907 let api_that_guard = api_that_guard.unwrap();
908 let output_ok = Result::<_, ()>::Ok(
909 crate::api::OndeChatEngine::unload_model(&*api_that_guard).await,
910 )?;
911 Ok(output_ok)
912 })()
913 .await,
914 )
915 }
916 },
917 )
918 }
919 fn wire__crate__api__configure_cache_dir_impl(
920 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
921 rust_vec_len_: i32,
922 data_len_: i32,
923 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
924 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
925 flutter_rust_bridge::for_generated::TaskInfo {
926 debug_name: "configure_cache_dir",
927 port: None,
928 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
929 },
930 move || {
931 let message = unsafe {
932 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
933 ptr_,
934 rust_vec_len_,
935 data_len_,
936 )
937 };
938 let mut deserializer =
939 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
940 let api_app_data_dir = <String>::sse_decode(&mut deserializer);
941 deserializer.end();
942 transform_result_sse::<_, crate::api::OndeError>((move || {
943 let output_ok = crate::api::configure_cache_dir(api_app_data_dir)?;
944 Ok(output_ok)
945 })())
946 },
947 )
948 }
949 fn wire__crate__api__default_model_config_impl(
950 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
951 rust_vec_len_: i32,
952 data_len_: i32,
953 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
954 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
955 flutter_rust_bridge::for_generated::TaskInfo {
956 debug_name: "default_model_config",
957 port: None,
958 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
959 },
960 move || {
961 let message = unsafe {
962 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
963 ptr_,
964 rust_vec_len_,
965 data_len_,
966 )
967 };
968 let mut deserializer =
969 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
970 deserializer.end();
971 transform_result_sse::<_, ()>((move || {
972 let output_ok = Result::<_, ()>::Ok(crate::api::default_model_config())?;
973 Ok(output_ok)
974 })())
975 },
976 )
977 }
978 fn wire__crate__api__default_sampling_config_impl(
979 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
980 rust_vec_len_: i32,
981 data_len_: i32,
982 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
983 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
984 flutter_rust_bridge::for_generated::TaskInfo {
985 debug_name: "default_sampling_config",
986 port: None,
987 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
988 },
989 move || {
990 let message = unsafe {
991 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
992 ptr_,
993 rust_vec_len_,
994 data_len_,
995 )
996 };
997 let mut deserializer =
998 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
999 deserializer.end();
1000 transform_result_sse::<_, ()>((move || {
1001 let output_ok = Result::<_, ()>::Ok(crate::api::default_sampling_config())?;
1002 Ok(output_ok)
1003 })())
1004 },
1005 )
1006 }
1007 fn wire__crate__api__deterministic_sampling_config_impl(
1008 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1009 rust_vec_len_: i32,
1010 data_len_: i32,
1011 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1012 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1013 flutter_rust_bridge::for_generated::TaskInfo {
1014 debug_name: "deterministic_sampling_config",
1015 port: None,
1016 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1017 },
1018 move || {
1019 let message = unsafe {
1020 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1021 ptr_,
1022 rust_vec_len_,
1023 data_len_,
1024 )
1025 };
1026 let mut deserializer =
1027 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1028 deserializer.end();
1029 transform_result_sse::<_, ()>((move || {
1030 let output_ok = Result::<_, ()>::Ok(crate::api::deterministic_sampling_config())?;
1031 Ok(output_ok)
1032 })())
1033 },
1034 )
1035 }
1036 fn wire__crate__api__mobile_sampling_config_impl(
1037 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1038 rust_vec_len_: i32,
1039 data_len_: i32,
1040 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1041 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1042 flutter_rust_bridge::for_generated::TaskInfo {
1043 debug_name: "mobile_sampling_config",
1044 port: None,
1045 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1046 },
1047 move || {
1048 let message = unsafe {
1049 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1050 ptr_,
1051 rust_vec_len_,
1052 data_len_,
1053 )
1054 };
1055 let mut deserializer =
1056 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1057 deserializer.end();
1058 transform_result_sse::<_, ()>((move || {
1059 let output_ok = Result::<_, ()>::Ok(crate::api::mobile_sampling_config())?;
1060 Ok(output_ok)
1061 })())
1062 },
1063 )
1064 }
1065 fn wire__crate__api__qwen25_1_5b_config_impl(
1066 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1067 rust_vec_len_: i32,
1068 data_len_: i32,
1069 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1070 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1071 flutter_rust_bridge::for_generated::TaskInfo {
1072 debug_name: "qwen25_1_5b_config",
1073 port: None,
1074 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1075 },
1076 move || {
1077 let message = unsafe {
1078 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1079 ptr_,
1080 rust_vec_len_,
1081 data_len_,
1082 )
1083 };
1084 let mut deserializer =
1085 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1086 deserializer.end();
1087 transform_result_sse::<_, ()>((move || {
1088 let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_1_5b_config())?;
1089 Ok(output_ok)
1090 })())
1091 },
1092 )
1093 }
1094 fn wire__crate__api__qwen25_3b_config_impl(
1095 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1096 rust_vec_len_: i32,
1097 data_len_: i32,
1098 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1099 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1100 flutter_rust_bridge::for_generated::TaskInfo {
1101 debug_name: "qwen25_3b_config",
1102 port: None,
1103 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1104 },
1105 move || {
1106 let message = unsafe {
1107 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1108 ptr_,
1109 rust_vec_len_,
1110 data_len_,
1111 )
1112 };
1113 let mut deserializer =
1114 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1115 deserializer.end();
1116 transform_result_sse::<_, ()>((move || {
1117 let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_3b_config())?;
1118 Ok(output_ok)
1119 })())
1120 },
1121 )
1122 }
1123 fn wire__crate__api__qwen25_coder_1_5b_config_impl(
1124 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1125 rust_vec_len_: i32,
1126 data_len_: i32,
1127 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1128 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1129 flutter_rust_bridge::for_generated::TaskInfo {
1130 debug_name: "qwen25_coder_1_5b_config",
1131 port: None,
1132 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1133 },
1134 move || {
1135 let message = unsafe {
1136 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1137 ptr_,
1138 rust_vec_len_,
1139 data_len_,
1140 )
1141 };
1142 let mut deserializer =
1143 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1144 deserializer.end();
1145 transform_result_sse::<_, ()>((move || {
1146 let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_coder_1_5b_config())?;
1147 Ok(output_ok)
1148 })())
1149 },
1150 )
1151 }
1152 fn wire__crate__api__qwen25_coder_3b_config_impl(
1153 ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1154 rust_vec_len_: i32,
1155 data_len_: i32,
1156 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1157 FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
1158 flutter_rust_bridge::for_generated::TaskInfo {
1159 debug_name: "qwen25_coder_3b_config",
1160 port: None,
1161 mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
1162 },
1163 move || {
1164 let message = unsafe {
1165 flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
1166 ptr_,
1167 rust_vec_len_,
1168 data_len_,
1169 )
1170 };
1171 let mut deserializer =
1172 flutter_rust_bridge::for_generated::SseDeserializer::new(message);
1173 deserializer.end();
1174 transform_result_sse::<_, ()>((move || {
1175 let output_ok = Result::<_, ()>::Ok(crate::api::qwen25_coder_3b_config())?;
1176 Ok(output_ok)
1177 })())
1178 },
1179 )
1180 }
1181
1182 // Section: related_funcs
1183
1184 flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
1185 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>
1186 );
1187
1188 // Section: dart2rust
1189
1190 impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
1191 // Codec=Sse (Serialization based), see doc to use other codecs
1192 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1193 let mut inner = <String>::sse_decode(deserializer);
1194 return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
1195 }
1196 }
1197
1198 impl SseDecode for OndeChatEngine {
1199 // Codec=Sse (Serialization based), see doc to use other codecs
1200 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1201 let mut inner = <RustOpaqueMoi<
1202 flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>,
1203 >>::sse_decode(deserializer);
1204 return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner);
1205 }
1206 }
1207
1208 impl SseDecode
1209 for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>
1210 {
1211 // Codec=Sse (Serialization based), see doc to use other codecs
1212 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1213 let mut inner = <usize>::sse_decode(deserializer);
1214 return decode_rust_opaque_moi(inner);
1215 }
1216 }
1217
1218 impl SseDecode
1219 for StreamSink<crate::api::StreamChunk, flutter_rust_bridge::for_generated::SseCodec>
1220 {
1221 // Codec=Sse (Serialization based), see doc to use other codecs
1222 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1223 let mut inner = <String>::sse_decode(deserializer);
1224 return StreamSink::deserialize(inner);
1225 }
1226 }
1227
1228 impl SseDecode for String {
1229 // Codec=Sse (Serialization based), see doc to use other codecs
1230 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1231 let mut inner = <Vec<u8>>::sse_decode(deserializer);
1232 return String::from_utf8(inner).unwrap();
1233 }
1234 }
1235
1236 impl SseDecode for bool {
1237 // Codec=Sse (Serialization based), see doc to use other codecs
1238 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1239 deserializer.cursor.read_u8().unwrap() != 0
1240 }
1241 }
1242
1243 impl SseDecode for crate::api::ChatMessage {
1244 // Codec=Sse (Serialization based), see doc to use other codecs
1245 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1246 let mut var_role = <crate::api::ChatRole>::sse_decode(deserializer);
1247 let mut var_content = <String>::sse_decode(deserializer);
1248 return crate::api::ChatMessage {
1249 role: var_role,
1250 content: var_content,
1251 };
1252 }
1253 }
1254
1255 impl SseDecode for crate::api::ChatRole {
1256 // Codec=Sse (Serialization based), see doc to use other codecs
1257 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1258 let mut inner = <i32>::sse_decode(deserializer);
1259 return match inner {
1260 0 => crate::api::ChatRole::System,
1261 1 => crate::api::ChatRole::User,
1262 2 => crate::api::ChatRole::Assistant,
1263 _ => unreachable!("Invalid variant for ChatRole: {}", inner),
1264 };
1265 }
1266 }
1267
1268 impl SseDecode for crate::api::EngineInfo {
1269 // Codec=Sse (Serialization based), see doc to use other codecs
1270 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1271 let mut var_status = <crate::api::EngineStatus>::sse_decode(deserializer);
1272 let mut var_modelName = <Option<String>>::sse_decode(deserializer);
1273 let mut var_approxMemory = <Option<String>>::sse_decode(deserializer);
1274 let mut var_historyLength = <u64>::sse_decode(deserializer);
1275 return crate::api::EngineInfo {
1276 status: var_status,
1277 model_name: var_modelName,
1278 approx_memory: var_approxMemory,
1279 history_length: var_historyLength,
1280 };
1281 }
1282 }
1283
1284 impl SseDecode for crate::api::EngineStatus {
1285 // Codec=Sse (Serialization based), see doc to use other codecs
1286 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1287 let mut inner = <i32>::sse_decode(deserializer);
1288 return match inner {
1289 0 => crate::api::EngineStatus::Unloaded,
1290 1 => crate::api::EngineStatus::Loading,
1291 2 => crate::api::EngineStatus::Ready,
1292 3 => crate::api::EngineStatus::Generating,
1293 4 => crate::api::EngineStatus::Error,
1294 _ => unreachable!("Invalid variant for EngineStatus: {}", inner),
1295 };
1296 }
1297 }
1298
1299 impl SseDecode for f32 {
1300 // Codec=Sse (Serialization based), see doc to use other codecs
1301 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1302 deserializer.cursor.read_f32::<NativeEndian>().unwrap()
1303 }
1304 }
1305
1306 impl SseDecode for f64 {
1307 // Codec=Sse (Serialization based), see doc to use other codecs
1308 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1309 deserializer.cursor.read_f64::<NativeEndian>().unwrap()
1310 }
1311 }
1312
1313 impl SseDecode for crate::api::GgufModelConfig {
1314 // Codec=Sse (Serialization based), see doc to use other codecs
1315 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1316 let mut var_modelId = <String>::sse_decode(deserializer);
1317 let mut var_files = <Vec<String>>::sse_decode(deserializer);
1318 let mut var_tokModelId = <Option<String>>::sse_decode(deserializer);
1319 let mut var_displayName = <String>::sse_decode(deserializer);
1320 let mut var_approxMemory = <String>::sse_decode(deserializer);
1321 return crate::api::GgufModelConfig {
1322 model_id: var_modelId,
1323 files: var_files,
1324 tok_model_id: var_tokModelId,
1325 display_name: var_displayName,
1326 approx_memory: var_approxMemory,
1327 };
1328 }
1329 }
1330
1331 impl SseDecode for i32 {
1332 // Codec=Sse (Serialization based), see doc to use other codecs
1333 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1334 deserializer.cursor.read_i32::<NativeEndian>().unwrap()
1335 }
1336 }
1337
1338 impl SseDecode for crate::api::InferenceResult {
1339 // Codec=Sse (Serialization based), see doc to use other codecs
1340 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1341 let mut var_text = <String>::sse_decode(deserializer);
1342 let mut var_durationSecs = <f64>::sse_decode(deserializer);
1343 let mut var_durationDisplay = <String>::sse_decode(deserializer);
1344 let mut var_finishReason = <String>::sse_decode(deserializer);
1345 let mut var_toolCalls = <Vec<crate::api::ToolCallInfo>>::sse_decode(deserializer);
1346 return crate::api::InferenceResult {
1347 text: var_text,
1348 duration_secs: var_durationSecs,
1349 duration_display: var_durationDisplay,
1350 finish_reason: var_finishReason,
1351 tool_calls: var_toolCalls,
1352 };
1353 }
1354 }
1355
1356 impl SseDecode for Vec<String> {
1357 // Codec=Sse (Serialization based), see doc to use other codecs
1358 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1359 let mut len_ = <i32>::sse_decode(deserializer);
1360 let mut ans_ = Vec::with_capacity(len_ as usize);
1361 for idx_ in 0..len_ {
1362 ans_.push(<String>::sse_decode(deserializer));
1363 }
1364 return ans_;
1365 }
1366 }
1367
1368 impl SseDecode for Vec<crate::api::ChatMessage> {
1369 // Codec=Sse (Serialization based), see doc to use other codecs
1370 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1371 let mut len_ = <i32>::sse_decode(deserializer);
1372 let mut ans_ = Vec::with_capacity(len_ as usize);
1373 for idx_ in 0..len_ {
1374 ans_.push(<crate::api::ChatMessage>::sse_decode(deserializer));
1375 }
1376 return ans_;
1377 }
1378 }
1379
1380 impl SseDecode for Vec<u8> {
1381 // Codec=Sse (Serialization based), see doc to use other codecs
1382 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1383 let mut len_ = <i32>::sse_decode(deserializer);
1384 let mut ans_ = Vec::with_capacity(len_ as usize);
1385 for idx_ in 0..len_ {
1386 ans_.push(<u8>::sse_decode(deserializer));
1387 }
1388 return ans_;
1389 }
1390 }
1391
1392 impl SseDecode for Vec<crate::api::ToolCallInfo> {
1393 // Codec=Sse (Serialization based), see doc to use other codecs
1394 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1395 let mut len_ = <i32>::sse_decode(deserializer);
1396 let mut ans_ = Vec::with_capacity(len_ as usize);
1397 for idx_ in 0..len_ {
1398 ans_.push(<crate::api::ToolCallInfo>::sse_decode(deserializer));
1399 }
1400 return ans_;
1401 }
1402 }
1403
1404 impl SseDecode for crate::api::OndeError {
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 let mut tag_ = <i32>::sse_decode(deserializer);
1408 match tag_ {
1409 0 => {
1410 return crate::api::OndeError::NoModelLoaded;
1411 }
1412 1 => {
1413 let mut var_modelName = <String>::sse_decode(deserializer);
1414 return crate::api::OndeError::AlreadyLoaded {
1415 model_name: var_modelName,
1416 };
1417 }
1418 2 => {
1419 let mut var_reason = <String>::sse_decode(deserializer);
1420 return crate::api::OndeError::ModelBuild { reason: var_reason };
1421 }
1422 3 => {
1423 let mut var_reason = <String>::sse_decode(deserializer);
1424 return crate::api::OndeError::Inference { reason: var_reason };
1425 }
1426 4 => {
1427 return crate::api::OndeError::Cancelled;
1428 }
1429 5 => {
1430 let mut var_reason = <String>::sse_decode(deserializer);
1431 return crate::api::OndeError::Other { reason: var_reason };
1432 }
1433 _ => {
1434 unimplemented!("");
1435 }
1436 }
1437 }
1438 }
1439
1440 impl SseDecode for Option<String> {
1441 // Codec=Sse (Serialization based), see doc to use other codecs
1442 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1443 if (<bool>::sse_decode(deserializer)) {
1444 return Some(<String>::sse_decode(deserializer));
1445 } else {
1446 return None;
1447 }
1448 }
1449 }
1450
1451 impl SseDecode for Option<f32> {
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 if (<bool>::sse_decode(deserializer)) {
1455 return Some(<f32>::sse_decode(deserializer));
1456 } else {
1457 return None;
1458 }
1459 }
1460 }
1461
1462 impl SseDecode for Option<f64> {
1463 // Codec=Sse (Serialization based), see doc to use other codecs
1464 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1465 if (<bool>::sse_decode(deserializer)) {
1466 return Some(<f64>::sse_decode(deserializer));
1467 } else {
1468 return None;
1469 }
1470 }
1471 }
1472
1473 impl SseDecode for Option<crate::api::SamplingConfig> {
1474 // Codec=Sse (Serialization based), see doc to use other codecs
1475 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1476 if (<bool>::sse_decode(deserializer)) {
1477 return Some(<crate::api::SamplingConfig>::sse_decode(deserializer));
1478 } else {
1479 return None;
1480 }
1481 }
1482 }
1483
1484 impl SseDecode for Option<u64> {
1485 // Codec=Sse (Serialization based), see doc to use other codecs
1486 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1487 if (<bool>::sse_decode(deserializer)) {
1488 return Some(<u64>::sse_decode(deserializer));
1489 } else {
1490 return None;
1491 }
1492 }
1493 }
1494
1495 impl SseDecode for crate::api::SamplingConfig {
1496 // Codec=Sse (Serialization based), see doc to use other codecs
1497 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1498 let mut var_temperature = <Option<f64>>::sse_decode(deserializer);
1499 let mut var_topP = <Option<f64>>::sse_decode(deserializer);
1500 let mut var_topK = <Option<u64>>::sse_decode(deserializer);
1501 let mut var_minP = <Option<f64>>::sse_decode(deserializer);
1502 let mut var_maxTokens = <Option<u64>>::sse_decode(deserializer);
1503 let mut var_frequencyPenalty = <Option<f32>>::sse_decode(deserializer);
1504 let mut var_presencePenalty = <Option<f32>>::sse_decode(deserializer);
1505 return crate::api::SamplingConfig {
1506 temperature: var_temperature,
1507 top_p: var_topP,
1508 top_k: var_topK,
1509 min_p: var_minP,
1510 max_tokens: var_maxTokens,
1511 frequency_penalty: var_frequencyPenalty,
1512 presence_penalty: var_presencePenalty,
1513 };
1514 }
1515 }
1516
1517 impl SseDecode for crate::api::StreamChunk {
1518 // Codec=Sse (Serialization based), see doc to use other codecs
1519 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1520 let mut var_delta = <String>::sse_decode(deserializer);
1521 let mut var_done = <bool>::sse_decode(deserializer);
1522 let mut var_finishReason = <Option<String>>::sse_decode(deserializer);
1523 return crate::api::StreamChunk {
1524 delta: var_delta,
1525 done: var_done,
1526 finish_reason: var_finishReason,
1527 };
1528 }
1529 }
1530
1531 impl SseDecode for crate::api::ToolCallInfo {
1532 // Codec=Sse (Serialization based), see doc to use other codecs
1533 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1534 let mut var_id = <String>::sse_decode(deserializer);
1535 let mut var_functionName = <String>::sse_decode(deserializer);
1536 let mut var_arguments = <String>::sse_decode(deserializer);
1537 return crate::api::ToolCallInfo {
1538 id: var_id,
1539 function_name: var_functionName,
1540 arguments: var_arguments,
1541 };
1542 }
1543 }
1544
1545 impl SseDecode for u64 {
1546 // Codec=Sse (Serialization based), see doc to use other codecs
1547 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1548 deserializer.cursor.read_u64::<NativeEndian>().unwrap()
1549 }
1550 }
1551
1552 impl SseDecode for u8 {
1553 // Codec=Sse (Serialization based), see doc to use other codecs
1554 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1555 deserializer.cursor.read_u8().unwrap()
1556 }
1557 }
1558
1559 impl SseDecode for () {
1560 // Codec=Sse (Serialization based), see doc to use other codecs
1561 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
1562 }
1563
1564 impl SseDecode for usize {
1565 // Codec=Sse (Serialization based), see doc to use other codecs
1566 fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
1567 deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
1568 }
1569 }
1570
1571 fn pde_ffi_dispatcher_primary_impl(
1572 func_id: i32,
1573 port: flutter_rust_bridge::for_generated::MessagePort,
1574 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1575 rust_vec_len: i32,
1576 data_len: i32,
1577 ) {
1578 // Codec=Pde (Serialization + dispatch), see doc to use other codecs
1579 match func_id {
1580 1 => wire__crate__api__OndeChatEngine_clear_history_impl(port, ptr, rust_vec_len, data_len),
1581 2 => wire__crate__api__OndeChatEngine_clear_system_prompt_impl(
1582 port,
1583 ptr,
1584 rust_vec_len,
1585 data_len,
1586 ),
1587 3 => wire__crate__api__OndeChatEngine_generate_impl(port, ptr, rust_vec_len, data_len),
1588 4 => wire__crate__api__OndeChatEngine_history_impl(port, ptr, rust_vec_len, data_len),
1589 5 => wire__crate__api__OndeChatEngine_info_impl(port, ptr, rust_vec_len, data_len),
1590 6 => wire__crate__api__OndeChatEngine_is_loaded_impl(port, ptr, rust_vec_len, data_len),
1591 7 => wire__crate__api__OndeChatEngine_load_assigned_model_impl(
1592 port,
1593 ptr,
1594 rust_vec_len,
1595 data_len,
1596 ),
1597 8 => {
1598 wire__crate__api__OndeChatEngine_load_gguf_model_impl(port, ptr, rust_vec_len, data_len)
1599 }
1600 10 => wire__crate__api__OndeChatEngine_push_history_impl(port, ptr, rust_vec_len, data_len),
1601 11 => wire__crate__api__OndeChatEngine_send_message_impl(port, ptr, rust_vec_len, data_len),
1602 12 => wire__crate__api__OndeChatEngine_set_sampling_impl(port, ptr, rust_vec_len, data_len),
1603 13 => wire__crate__api__OndeChatEngine_set_system_prompt_impl(
1604 port,
1605 ptr,
1606 rust_vec_len,
1607 data_len,
1608 ),
1609 14 => {
1610 wire__crate__api__OndeChatEngine_stream_message_impl(port, ptr, rust_vec_len, data_len)
1611 }
1612 15 => wire__crate__api__OndeChatEngine_unload_model_impl(port, ptr, rust_vec_len, data_len),
1613 _ => unreachable!(),
1614 }
1615 }
1616
1617 fn pde_ffi_dispatcher_sync_impl(
1618 func_id: i32,
1619 ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
1620 rust_vec_len: i32,
1621 data_len: i32,
1622 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
1623 // Codec=Pde (Serialization + dispatch), see doc to use other codecs
1624 match func_id {
1625 9 => wire__crate__api__OndeChatEngine_new_impl(ptr, rust_vec_len, data_len),
1626 16 => wire__crate__api__configure_cache_dir_impl(ptr, rust_vec_len, data_len),
1627 17 => wire__crate__api__default_model_config_impl(ptr, rust_vec_len, data_len),
1628 18 => wire__crate__api__default_sampling_config_impl(ptr, rust_vec_len, data_len),
1629 19 => wire__crate__api__deterministic_sampling_config_impl(ptr, rust_vec_len, data_len),
1630 20 => wire__crate__api__mobile_sampling_config_impl(ptr, rust_vec_len, data_len),
1631 21 => wire__crate__api__qwen25_1_5b_config_impl(ptr, rust_vec_len, data_len),
1632 22 => wire__crate__api__qwen25_3b_config_impl(ptr, rust_vec_len, data_len),
1633 23 => wire__crate__api__qwen25_coder_1_5b_config_impl(ptr, rust_vec_len, data_len),
1634 24 => wire__crate__api__qwen25_coder_3b_config_impl(ptr, rust_vec_len, data_len),
1635 _ => unreachable!(),
1636 }
1637 }
1638
1639 // Section: rust2dart
1640
1641 // Codec=Dco (DartCObject based), see doc to use other codecs
1642 impl flutter_rust_bridge::IntoDart for FrbWrapper<OndeChatEngine> {
1643 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1644 flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0)
1645 .into_dart()
1646 }
1647 }
1648 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for FrbWrapper<OndeChatEngine> {}
1649
1650 impl flutter_rust_bridge::IntoIntoDart<FrbWrapper<OndeChatEngine>> for OndeChatEngine {
1651 fn into_into_dart(self) -> FrbWrapper<OndeChatEngine> {
1652 self.into()
1653 }
1654 }
1655
1656 // Codec=Dco (DartCObject based), see doc to use other codecs
1657 impl flutter_rust_bridge::IntoDart for crate::api::ChatMessage {
1658 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1659 [
1660 self.role.into_into_dart().into_dart(),
1661 self.content.into_into_dart().into_dart(),
1662 ]
1663 .into_dart()
1664 }
1665 }
1666 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ChatMessage {}
1667 impl flutter_rust_bridge::IntoIntoDart<crate::api::ChatMessage> for crate::api::ChatMessage {
1668 fn into_into_dart(self) -> crate::api::ChatMessage {
1669 self
1670 }
1671 }
1672 // Codec=Dco (DartCObject based), see doc to use other codecs
1673 impl flutter_rust_bridge::IntoDart for crate::api::ChatRole {
1674 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1675 match self {
1676 Self::System => 0.into_dart(),
1677 Self::User => 1.into_dart(),
1678 Self::Assistant => 2.into_dart(),
1679 _ => unreachable!(),
1680 }
1681 }
1682 }
1683 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ChatRole {}
1684 impl flutter_rust_bridge::IntoIntoDart<crate::api::ChatRole> for crate::api::ChatRole {
1685 fn into_into_dart(self) -> crate::api::ChatRole {
1686 self
1687 }
1688 }
1689 // Codec=Dco (DartCObject based), see doc to use other codecs
1690 impl flutter_rust_bridge::IntoDart for crate::api::EngineInfo {
1691 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1692 [
1693 self.status.into_into_dart().into_dart(),
1694 self.model_name.into_into_dart().into_dart(),
1695 self.approx_memory.into_into_dart().into_dart(),
1696 self.history_length.into_into_dart().into_dart(),
1697 ]
1698 .into_dart()
1699 }
1700 }
1701 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::EngineInfo {}
1702 impl flutter_rust_bridge::IntoIntoDart<crate::api::EngineInfo> for crate::api::EngineInfo {
1703 fn into_into_dart(self) -> crate::api::EngineInfo {
1704 self
1705 }
1706 }
1707 // Codec=Dco (DartCObject based), see doc to use other codecs
1708 impl flutter_rust_bridge::IntoDart for crate::api::EngineStatus {
1709 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1710 match self {
1711 Self::Unloaded => 0.into_dart(),
1712 Self::Loading => 1.into_dart(),
1713 Self::Ready => 2.into_dart(),
1714 Self::Generating => 3.into_dart(),
1715 Self::Error => 4.into_dart(),
1716 _ => unreachable!(),
1717 }
1718 }
1719 }
1720 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::EngineStatus {}
1721 impl flutter_rust_bridge::IntoIntoDart<crate::api::EngineStatus> for crate::api::EngineStatus {
1722 fn into_into_dart(self) -> crate::api::EngineStatus {
1723 self
1724 }
1725 }
1726 // Codec=Dco (DartCObject based), see doc to use other codecs
1727 impl flutter_rust_bridge::IntoDart for crate::api::GgufModelConfig {
1728 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1729 [
1730 self.model_id.into_into_dart().into_dart(),
1731 self.files.into_into_dart().into_dart(),
1732 self.tok_model_id.into_into_dart().into_dart(),
1733 self.display_name.into_into_dart().into_dart(),
1734 self.approx_memory.into_into_dart().into_dart(),
1735 ]
1736 .into_dart()
1737 }
1738 }
1739 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::GgufModelConfig {}
1740 impl flutter_rust_bridge::IntoIntoDart<crate::api::GgufModelConfig>
1741 for crate::api::GgufModelConfig
1742 {
1743 fn into_into_dart(self) -> crate::api::GgufModelConfig {
1744 self
1745 }
1746 }
1747 // Codec=Dco (DartCObject based), see doc to use other codecs
1748 impl flutter_rust_bridge::IntoDart for crate::api::InferenceResult {
1749 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1750 [
1751 self.text.into_into_dart().into_dart(),
1752 self.duration_secs.into_into_dart().into_dart(),
1753 self.duration_display.into_into_dart().into_dart(),
1754 self.finish_reason.into_into_dart().into_dart(),
1755 self.tool_calls.into_into_dart().into_dart(),
1756 ]
1757 .into_dart()
1758 }
1759 }
1760 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::InferenceResult {}
1761 impl flutter_rust_bridge::IntoIntoDart<crate::api::InferenceResult>
1762 for crate::api::InferenceResult
1763 {
1764 fn into_into_dart(self) -> crate::api::InferenceResult {
1765 self
1766 }
1767 }
1768 // Codec=Dco (DartCObject based), see doc to use other codecs
1769 impl flutter_rust_bridge::IntoDart for crate::api::OndeError {
1770 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1771 match self {
1772 crate::api::OndeError::NoModelLoaded => [0.into_dart()].into_dart(),
1773 crate::api::OndeError::AlreadyLoaded { model_name } => {
1774 [1.into_dart(), model_name.into_into_dart().into_dart()].into_dart()
1775 }
1776 crate::api::OndeError::ModelBuild { reason } => {
1777 [2.into_dart(), reason.into_into_dart().into_dart()].into_dart()
1778 }
1779 crate::api::OndeError::Inference { reason } => {
1780 [3.into_dart(), reason.into_into_dart().into_dart()].into_dart()
1781 }
1782 crate::api::OndeError::Cancelled => [4.into_dart()].into_dart(),
1783 crate::api::OndeError::Other { reason } => {
1784 [5.into_dart(), reason.into_into_dart().into_dart()].into_dart()
1785 }
1786 _ => {
1787 unimplemented!("");
1788 }
1789 }
1790 }
1791 }
1792 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::OndeError {}
1793 impl flutter_rust_bridge::IntoIntoDart<crate::api::OndeError> for crate::api::OndeError {
1794 fn into_into_dart(self) -> crate::api::OndeError {
1795 self
1796 }
1797 }
1798 // Codec=Dco (DartCObject based), see doc to use other codecs
1799 impl flutter_rust_bridge::IntoDart for crate::api::SamplingConfig {
1800 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1801 [
1802 self.temperature.into_into_dart().into_dart(),
1803 self.top_p.into_into_dart().into_dart(),
1804 self.top_k.into_into_dart().into_dart(),
1805 self.min_p.into_into_dart().into_dart(),
1806 self.max_tokens.into_into_dart().into_dart(),
1807 self.frequency_penalty.into_into_dart().into_dart(),
1808 self.presence_penalty.into_into_dart().into_dart(),
1809 ]
1810 .into_dart()
1811 }
1812 }
1813 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::SamplingConfig {}
1814 impl flutter_rust_bridge::IntoIntoDart<crate::api::SamplingConfig> for crate::api::SamplingConfig {
1815 fn into_into_dart(self) -> crate::api::SamplingConfig {
1816 self
1817 }
1818 }
1819 // Codec=Dco (DartCObject based), see doc to use other codecs
1820 impl flutter_rust_bridge::IntoDart for crate::api::StreamChunk {
1821 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1822 [
1823 self.delta.into_into_dart().into_dart(),
1824 self.done.into_into_dart().into_dart(),
1825 self.finish_reason.into_into_dart().into_dart(),
1826 ]
1827 .into_dart()
1828 }
1829 }
1830 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::StreamChunk {}
1831 impl flutter_rust_bridge::IntoIntoDart<crate::api::StreamChunk> for crate::api::StreamChunk {
1832 fn into_into_dart(self) -> crate::api::StreamChunk {
1833 self
1834 }
1835 }
1836 // Codec=Dco (DartCObject based), see doc to use other codecs
1837 impl flutter_rust_bridge::IntoDart for crate::api::ToolCallInfo {
1838 fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
1839 [
1840 self.id.into_into_dart().into_dart(),
1841 self.function_name.into_into_dart().into_dart(),
1842 self.arguments.into_into_dart().into_dart(),
1843 ]
1844 .into_dart()
1845 }
1846 }
1847 impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::ToolCallInfo {}
1848 impl flutter_rust_bridge::IntoIntoDart<crate::api::ToolCallInfo> for crate::api::ToolCallInfo {
1849 fn into_into_dart(self) -> crate::api::ToolCallInfo {
1850 self
1851 }
1852 }
1853
1854 impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
1855 // Codec=Sse (Serialization based), see doc to use other codecs
1856 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1857 <String>::sse_encode(format!("{:?}", self), serializer);
1858 }
1859 }
1860
1861 impl SseEncode for OndeChatEngine {
1862 // Codec=Sse (Serialization based), see doc to use other codecs
1863 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1864 <RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
1865 }
1866 }
1867
1868 impl SseEncode
1869 for RustOpaqueMoi<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>
1870 {
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 let (ptr, size) = self.sse_encode_raw();
1874 <usize>::sse_encode(ptr, serializer);
1875 <i32>::sse_encode(size, serializer);
1876 }
1877 }
1878
1879 impl SseEncode
1880 for StreamSink<crate::api::StreamChunk, flutter_rust_bridge::for_generated::SseCodec>
1881 {
1882 // Codec=Sse (Serialization based), see doc to use other codecs
1883 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1884 unimplemented!("")
1885 }
1886 }
1887
1888 impl SseEncode for String {
1889 // Codec=Sse (Serialization based), see doc to use other codecs
1890 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1891 <Vec<u8>>::sse_encode(self.into_bytes(), serializer);
1892 }
1893 }
1894
1895 impl SseEncode for bool {
1896 // Codec=Sse (Serialization based), see doc to use other codecs
1897 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1898 serializer.cursor.write_u8(self as _).unwrap();
1899 }
1900 }
1901
1902 impl SseEncode for crate::api::ChatMessage {
1903 // Codec=Sse (Serialization based), see doc to use other codecs
1904 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1905 <crate::api::ChatRole>::sse_encode(self.role, serializer);
1906 <String>::sse_encode(self.content, serializer);
1907 }
1908 }
1909
1910 impl SseEncode for crate::api::ChatRole {
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 <i32>::sse_encode(
1914 match self {
1915 crate::api::ChatRole::System => 0,
1916 crate::api::ChatRole::User => 1,
1917 crate::api::ChatRole::Assistant => 2,
1918 _ => {
1919 unimplemented!("");
1920 }
1921 },
1922 serializer,
1923 );
1924 }
1925 }
1926
1927 impl SseEncode for crate::api::EngineInfo {
1928 // Codec=Sse (Serialization based), see doc to use other codecs
1929 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1930 <crate::api::EngineStatus>::sse_encode(self.status, serializer);
1931 <Option<String>>::sse_encode(self.model_name, serializer);
1932 <Option<String>>::sse_encode(self.approx_memory, serializer);
1933 <u64>::sse_encode(self.history_length, serializer);
1934 }
1935 }
1936
1937 impl SseEncode for crate::api::EngineStatus {
1938 // Codec=Sse (Serialization based), see doc to use other codecs
1939 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1940 <i32>::sse_encode(
1941 match self {
1942 crate::api::EngineStatus::Unloaded => 0,
1943 crate::api::EngineStatus::Loading => 1,
1944 crate::api::EngineStatus::Ready => 2,
1945 crate::api::EngineStatus::Generating => 3,
1946 crate::api::EngineStatus::Error => 4,
1947 _ => {
1948 unimplemented!("");
1949 }
1950 },
1951 serializer,
1952 );
1953 }
1954 }
1955
1956 impl SseEncode for f32 {
1957 // Codec=Sse (Serialization based), see doc to use other codecs
1958 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1959 serializer.cursor.write_f32::<NativeEndian>(self).unwrap();
1960 }
1961 }
1962
1963 impl SseEncode for 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 serializer.cursor.write_f64::<NativeEndian>(self).unwrap();
1967 }
1968 }
1969
1970 impl SseEncode for crate::api::GgufModelConfig {
1971 // Codec=Sse (Serialization based), see doc to use other codecs
1972 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1973 <String>::sse_encode(self.model_id, serializer);
1974 <Vec<String>>::sse_encode(self.files, serializer);
1975 <Option<String>>::sse_encode(self.tok_model_id, serializer);
1976 <String>::sse_encode(self.display_name, serializer);
1977 <String>::sse_encode(self.approx_memory, serializer);
1978 }
1979 }
1980
1981 impl SseEncode for i32 {
1982 // Codec=Sse (Serialization based), see doc to use other codecs
1983 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1984 serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
1985 }
1986 }
1987
1988 impl SseEncode for crate::api::InferenceResult {
1989 // Codec=Sse (Serialization based), see doc to use other codecs
1990 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
1991 <String>::sse_encode(self.text, serializer);
1992 <f64>::sse_encode(self.duration_secs, serializer);
1993 <String>::sse_encode(self.duration_display, serializer);
1994 <String>::sse_encode(self.finish_reason, serializer);
1995 <Vec<crate::api::ToolCallInfo>>::sse_encode(self.tool_calls, serializer);
1996 }
1997 }
1998
1999 impl SseEncode for Vec<String> {
2000 // Codec=Sse (Serialization based), see doc to use other codecs
2001 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2002 <i32>::sse_encode(self.len() as _, serializer);
2003 for item in self {
2004 <String>::sse_encode(item, serializer);
2005 }
2006 }
2007 }
2008
2009 impl SseEncode for Vec<crate::api::ChatMessage> {
2010 // Codec=Sse (Serialization based), see doc to use other codecs
2011 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2012 <i32>::sse_encode(self.len() as _, serializer);
2013 for item in self {
2014 <crate::api::ChatMessage>::sse_encode(item, serializer);
2015 }
2016 }
2017 }
2018
2019 impl SseEncode for Vec<u8> {
2020 // Codec=Sse (Serialization based), see doc to use other codecs
2021 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2022 <i32>::sse_encode(self.len() as _, serializer);
2023 for item in self {
2024 <u8>::sse_encode(item, serializer);
2025 }
2026 }
2027 }
2028
2029 impl SseEncode for Vec<crate::api::ToolCallInfo> {
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 <i32>::sse_encode(self.len() as _, serializer);
2033 for item in self {
2034 <crate::api::ToolCallInfo>::sse_encode(item, serializer);
2035 }
2036 }
2037 }
2038
2039 impl SseEncode for crate::api::OndeError {
2040 // Codec=Sse (Serialization based), see doc to use other codecs
2041 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2042 match self {
2043 crate::api::OndeError::NoModelLoaded => {
2044 <i32>::sse_encode(0, serializer);
2045 }
2046 crate::api::OndeError::AlreadyLoaded { model_name } => {
2047 <i32>::sse_encode(1, serializer);
2048 <String>::sse_encode(model_name, serializer);
2049 }
2050 crate::api::OndeError::ModelBuild { reason } => {
2051 <i32>::sse_encode(2, serializer);
2052 <String>::sse_encode(reason, serializer);
2053 }
2054 crate::api::OndeError::Inference { reason } => {
2055 <i32>::sse_encode(3, serializer);
2056 <String>::sse_encode(reason, serializer);
2057 }
2058 crate::api::OndeError::Cancelled => {
2059 <i32>::sse_encode(4, serializer);
2060 }
2061 crate::api::OndeError::Other { reason } => {
2062 <i32>::sse_encode(5, serializer);
2063 <String>::sse_encode(reason, serializer);
2064 }
2065 _ => {
2066 unimplemented!("");
2067 }
2068 }
2069 }
2070 }
2071
2072 impl SseEncode for Option<String> {
2073 // Codec=Sse (Serialization based), see doc to use other codecs
2074 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2075 <bool>::sse_encode(self.is_some(), serializer);
2076 if let Some(value) = self {
2077 <String>::sse_encode(value, serializer);
2078 }
2079 }
2080 }
2081
2082 impl SseEncode for Option<f32> {
2083 // Codec=Sse (Serialization based), see doc to use other codecs
2084 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2085 <bool>::sse_encode(self.is_some(), serializer);
2086 if let Some(value) = self {
2087 <f32>::sse_encode(value, serializer);
2088 }
2089 }
2090 }
2091
2092 impl SseEncode for Option<f64> {
2093 // Codec=Sse (Serialization based), see doc to use other codecs
2094 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2095 <bool>::sse_encode(self.is_some(), serializer);
2096 if let Some(value) = self {
2097 <f64>::sse_encode(value, serializer);
2098 }
2099 }
2100 }
2101
2102 impl SseEncode for Option<crate::api::SamplingConfig> {
2103 // Codec=Sse (Serialization based), see doc to use other codecs
2104 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2105 <bool>::sse_encode(self.is_some(), serializer);
2106 if let Some(value) = self {
2107 <crate::api::SamplingConfig>::sse_encode(value, serializer);
2108 }
2109 }
2110 }
2111
2112 impl SseEncode for Option<u64> {
2113 // Codec=Sse (Serialization based), see doc to use other codecs
2114 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2115 <bool>::sse_encode(self.is_some(), serializer);
2116 if let Some(value) = self {
2117 <u64>::sse_encode(value, serializer);
2118 }
2119 }
2120 }
2121
2122 impl SseEncode for crate::api::SamplingConfig {
2123 // Codec=Sse (Serialization based), see doc to use other codecs
2124 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2125 <Option<f64>>::sse_encode(self.temperature, serializer);
2126 <Option<f64>>::sse_encode(self.top_p, serializer);
2127 <Option<u64>>::sse_encode(self.top_k, serializer);
2128 <Option<f64>>::sse_encode(self.min_p, serializer);
2129 <Option<u64>>::sse_encode(self.max_tokens, serializer);
2130 <Option<f32>>::sse_encode(self.frequency_penalty, serializer);
2131 <Option<f32>>::sse_encode(self.presence_penalty, serializer);
2132 }
2133 }
2134
2135 impl SseEncode for crate::api::StreamChunk {
2136 // Codec=Sse (Serialization based), see doc to use other codecs
2137 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2138 <String>::sse_encode(self.delta, serializer);
2139 <bool>::sse_encode(self.done, serializer);
2140 <Option<String>>::sse_encode(self.finish_reason, serializer);
2141 }
2142 }
2143
2144 impl SseEncode for crate::api::ToolCallInfo {
2145 // Codec=Sse (Serialization based), see doc to use other codecs
2146 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2147 <String>::sse_encode(self.id, serializer);
2148 <String>::sse_encode(self.function_name, serializer);
2149 <String>::sse_encode(self.arguments, serializer);
2150 }
2151 }
2152
2153 impl SseEncode for u64 {
2154 // Codec=Sse (Serialization based), see doc to use other codecs
2155 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2156 serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
2157 }
2158 }
2159
2160 impl SseEncode for u8 {
2161 // Codec=Sse (Serialization based), see doc to use other codecs
2162 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2163 serializer.cursor.write_u8(self).unwrap();
2164 }
2165 }
2166
2167 impl SseEncode for () {
2168 // Codec=Sse (Serialization based), see doc to use other codecs
2169 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
2170 }
2171
2172 impl SseEncode for usize {
2173 // Codec=Sse (Serialization based), see doc to use other codecs
2174 fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
2175 serializer
2176 .cursor
2177 .write_u64::<NativeEndian>(self as _)
2178 .unwrap();
2179 }
2180 }
2181
2182 #[cfg(not(target_family = "wasm"))]
2183 mod io {
2184 // This file is automatically generated, so please do not edit it.
2185 // @generated by `flutter_rust_bridge`@ 2.12.0.
2186
2187 // Section: imports
2188
2189 use super::*;
2190 use crate::api::*;
2191 use flutter_rust_bridge::for_generated::byteorder::{
2192 NativeEndian, ReadBytesExt, WriteBytesExt,
2193 };
2194 use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
2195 use flutter_rust_bridge::{Handler, IntoIntoDart};
2196
2197 // Section: boilerplate
2198
2199 flutter_rust_bridge::frb_generated_boilerplate_io!();
2200
2201 #[unsafe(no_mangle)]
2202 pub extern "C" fn frbgen_onde_inference_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOndeChatEngine(
2203 ptr: *const std::ffi::c_void,
2204 ) {
2205 MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>::increment_strong_count(ptr as _);
2206 }
2207
2208 #[unsafe(no_mangle)]
2209 pub extern "C" fn frbgen_onde_inference_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerOndeChatEngine(
2210 ptr: *const std::ffi::c_void,
2211 ) {
2212 MoiArc::<flutter_rust_bridge::for_generated::RustAutoOpaqueInner<OndeChatEngine>>::decrement_strong_count(ptr as _);
2213 }
2214 }
2215 #[cfg(not(target_family = "wasm"))]
2216 pub use io::*;