ringo-fm 0.1.1

Idiomatic Rust bindings for Apple's on-device Foundation Models framework
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! `GeneratedContent` — opaque parsed structured-generation output.

use std::ffi::CString;

use ringo_fm_sys as sys;
use serde::de::DeserializeOwned;

use crate::error::{Error, Result};
use crate::handle::{check_error, FmString, ManagedRef};

pub(crate) struct GeneratedContentTag;

/// Parsed structured-generation output. Backed by a JSON document on the C side.
pub struct GeneratedContent {
    pub(crate) handle: ManagedRef<GeneratedContentTag>,
}

impl GeneratedContent {
    pub fn from_json(json: &str) -> Result<Self> {
        let c = CString::new(json).map_err(|e| Error::Native(e.to_string()))?;
        let mut code: i32 = 0;
        let mut desc: *mut i8 = std::ptr::null_mut();
        let ptr = unsafe { sys::FMGeneratedContentCreateFromJSON(c.as_ptr(), &mut code, &mut desc) };
        check_error(code, desc)?;
        Ok(Self { handle: ManagedRef::from_owned(ptr)? })
    }

    pub fn to_json(&self) -> Result<String> {
        let ptr = unsafe { sys::FMGeneratedContentGetJSONString(self.handle.as_ptr()) };
        FmString::from_raw(ptr)
            .ok_or_else(|| Error::Native("generated content JSON null".into()))?
            .to_string()
    }

    /// Deserialize the content into any `serde::DeserializeOwned` type.
    pub fn decode<T: DeserializeOwned>(&self) -> Result<T> {
        let json = self.to_json()?;
        serde_json::from_str(&json).map_err(|e| Error::Native(e.to_string()))
    }

    /// Parse the content as a generic JSON value.
    pub fn as_value(&self) -> Result<serde_json::Value> {
        let json = self.to_json()?;
        serde_json::from_str(&json).map_err(|e| Error::Native(e.to_string()))
    }

    pub fn get_property(&self, name: &str) -> Result<String> {
        let c = CString::new(name).map_err(|e| Error::Native(e.to_string()))?;
        let mut code: i32 = 0;
        let mut desc: *mut i8 = std::ptr::null_mut();
        let ptr = unsafe {
            sys::FMGeneratedContentGetPropertyValue(self.handle.as_ptr(), c.as_ptr(), &mut code, &mut desc)
        };
        check_error(code, desc)?;
        FmString::from_raw(ptr)
            .ok_or_else(|| Error::Native("property value null".into()))?
            .to_string()
    }

    /// Returns the value of a numeric property as `f64`, or `None` if absent or wrong type.
    pub fn value_as_f64(&self, name: &str) -> Option<f64> {
        let c = CString::new(name).ok()?;
        let mut out: f64 = 0.0;
        let mut code: i32 = 0;
        let ok = unsafe {
            sys::FMGeneratedContentGetPropertyValueAsDouble(
                self.handle.as_ptr(),
                c.as_ptr(),
                &mut out,
                &mut code,
            )
        };
        if ok { Some(out) } else { None }
    }

    /// Returns the value of an integer property as `i64`, or `None` if absent or wrong type.
    pub fn value_as_i64(&self, name: &str) -> Option<i64> {
        let c = CString::new(name).ok()?;
        let mut out: i64 = 0;
        let mut code: i32 = 0;
        let ok = unsafe {
            sys::FMGeneratedContentGetPropertyValueAsInt(
                self.handle.as_ptr(),
                c.as_ptr(),
                &mut out,
                &mut code,
            )
        };
        if ok { Some(out) } else { None }
    }

    /// Returns the value of a boolean property, or `None` if absent or wrong type.
    pub fn value_as_bool(&self, name: &str) -> Option<bool> {
        let c = CString::new(name).ok()?;
        let mut out: bool = false;
        let mut code: i32 = 0;
        let ok = unsafe {
            sys::FMGeneratedContentGetPropertyValueAsBool(
                self.handle.as_ptr(),
                c.as_ptr(),
                &mut out,
                &mut code,
            )
        };
        if ok { Some(out) } else { None }
    }

    /// Reports whether the content has a top-level property with `name`.
    pub fn has_property(&self, name: &str) -> bool {
        let Ok(c) = CString::new(name) else { return false };
        unsafe { sys::FMGeneratedContentHasProperty(self.handle.as_ptr(), c.as_ptr()) }
    }

    /// Returns the sorted list of top-level property names.
    pub fn property_names(&self) -> Result<Vec<String>> {
        let ptr = unsafe { sys::FMGeneratedContentGetPropertyNames(self.handle.as_ptr()) };
        let json = FmString::from_raw(ptr)
            .ok_or_else(|| Error::Native("property names null".into()))?
            .to_string()?;
        serde_json::from_str::<Vec<String>>(&json).map_err(|e| Error::Native(e.to_string()))
    }

    pub fn is_complete(&self) -> bool {
        unsafe { sys::FMGeneratedContentIsComplete(self.handle.as_ptr()) }
    }
}

impl std::fmt::Debug for GeneratedContent {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self.to_json() {
            Ok(j) => write!(f, "GeneratedContent({j})"),
            Err(_) => f.debug_struct("GeneratedContent").finish_non_exhaustive(),
        }
    }
}