baml-cc 0.208.5

data/ext/ruby_ffi/src/types/client_registry.rs

@@ -0,0 +1,71 @@
+use std::{cell::RefCell, str::FromStr};
+
+use baml_runtime::client_registry;
+use magnus::{
+    class, function, method, scan_args::scan_args, Error, Module, Object, RHash, Ruby, Value,
+};
+
+use crate::{ruby_to_json, Result};
+
+#[magnus::wrap(class = "Baml::Ffi::ClientRegistry", free_immediately, size)]
+pub(crate) struct ClientRegistry {
+    // This is the pattern suggeested in https://github.com/matsadler/magnus/blob/main/examples/mut_point.rs
+    pub(crate) inner: RefCell<client_registry::ClientRegistry>,
+}
+
+impl ClientRegistry {
+    pub fn new() -> Self {
+        Self {
+            inner: RefCell::new(client_registry::ClientRegistry::new()),
+        }
+    }
+
+    pub fn add_llm_client(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<()> {
+        let args = scan_args::<_, _, (), (), (), ()>(args)?;
+        let (name, provider, options): (String, String, RHash) = args.required;
+        let (retry_policy,): (Option<String>,) = args.optional;
+
+        let options = match ruby_to_json::RubyToJson::convert_hash_to_json(options) {
+            Ok(options) => options,
+            Err(e) => {
+                return Err(Error::new(
+                    ruby.exception_syntax_error(),
+                    format!("error while parsing call_function args:\n{e}"),
+                ));
+            }
+        };
+
+        let provider = match client_registry::ClientProvider::from_str(&provider) {
+            Ok(provider) => provider,
+            Err(e) => {
+                return Err(Error::new(
+                    ruby.exception_syntax_error(),
+                    format!("Invalid provider: {e:?}"),
+                ));
+            }
+        };
+
+        let client_property =
+            client_registry::ClientProperty::new(name, provider, retry_policy, options);
+
+        rb_self.inner.borrow_mut().add_client(client_property);
+        Ok(())
+    }
+
+    pub fn set_primary(&self, primary: String) {
+        self.inner.borrow_mut().set_primary(primary);
+    }
+
+    pub fn define_in_ruby(module: &magnus::RModule) -> Result<()> {
+        let cls = module.define_class("ClientRegistry", class::object())?;
+
+        cls.define_singleton_method("new", function!(ClientRegistry::new, 0))?;
+        cls.define_method(
+            "add_llm_client",
+            method!(ClientRegistry::add_llm_client, -1),
+        )?;
+        cls.define_method("set_primary", method!(ClientRegistry::set_primary, 1))?;
+
+        Ok(())
+    }
+}

data/ext/ruby_ffi/src/types/lang_wrapper.rs

@@ -0,0 +1,60 @@
+#[macro_export]
+macro_rules! lang_wrapper {
+
+    ($name:ident, $wrap_name:expr, $type:ty, sync_thread_safe $(, $attr_name:ident : $attr_type:ty)*) => {
+        #[magnus::wrap(class = $wrap_name, free_immediately, size)]
+        pub struct $name {
+            pub(crate) inner: std::sync::Arc<std::sync::Mutex<$type>>,
+            $($attr_name: $attr_type),*
+        }
+
+        impl From<$type> for $name {
+            fn from(inner: $type) -> Self {
+                Self {
+                    inner: std::sync::Arc::new(std::sync::Mutex::new(inner)),
+                    $($attr_name: Default::default()),*
+                }
+            }
+        }
+
+
+        impl From<std::sync::Arc<std::sync::Mutex<$type>>> for $name {
+            fn from(inner: std::sync::Arc<std::sync::Mutex<$type>>) -> Self {
+                Self {
+                    inner,
+                    $($attr_name: Default::default()),*
+                }
+            }
+        }
+    };
+
+
+    ($name:ident, $wrap_name:expr, $type:ty, clone_safe $(, $attr_name:ident : $attr_type:ty)*) => {
+        #[magnus::wrap(class = $wrap_name, free_immediately, size)]
+        pub struct $name {
+            pub(crate) inner: std::sync::Arc<$type>,
+            $($attr_name: $attr_type),*
+        }
+
+        impl From<$type> for $name {
+            fn from(inner: $type) -> Self {
+                Self {
+                    inner: std::sync::Arc::new(inner),
+                    $($attr_name: Default::default()),*
+                }
+            }
+        }
+
+
+        impl From<std::sync::Arc<$type>> for $name {
+            fn from(inner: std::sync::Arc<$type>) -> Self {
+                Self {
+                    inner,
+                    $($attr_name: Default::default()),*
+                }
+            }
+        }
+    };
+
+
+}