baml-cc 0.208.5

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

@@ -0,0 +1,142 @@
+use baml_types::{BamlMedia, BamlMediaType, BamlValue};
+use magnus::{class, function, Module, Object, RModule};
+
+use crate::Result;
+
+pub(crate) trait CloneAsBamlValue {
+    fn clone_as_baml_value(&self) -> BamlValue;
+}
+
+#[magnus::wrap(class = "Baml::Ffi::Image", free_immediately, size)]
+pub(crate) struct Image {
+    pub(crate) inner: baml_types::BamlMedia,
+}
+
+impl Image {
+    pub fn from_url(url: String, media_type: Option<String>) -> Self {
+        Self {
+            inner: BamlMedia::url(BamlMediaType::Image, url, media_type),
+        }
+    }
+
+    pub fn from_base64(media_type: String, base64: String) -> Self {
+        Self {
+            inner: BamlMedia::base64(BamlMediaType::Image, base64, Some(media_type)),
+        }
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("Image", class::object())?;
+        cls.define_singleton_method("from_url", function!(Image::from_url, 2))?;
+        cls.define_singleton_method("from_base64", function!(Image::from_base64, 2))?;
+
+        Ok(())
+    }
+}
+
+impl CloneAsBamlValue for Image {
+    fn clone_as_baml_value(&self) -> BamlValue {
+        BamlValue::Media(self.inner.clone())
+    }
+}
+
+#[magnus::wrap(class = "Baml::Ffi::Audio", free_immediately, size)]
+pub(crate) struct Audio {
+    pub(crate) inner: BamlMedia,
+}
+
+impl Audio {
+    pub fn from_url(url: String, media_type: Option<String>) -> Self {
+        Self {
+            inner: BamlMedia::url(BamlMediaType::Audio, url, media_type),
+        }
+    }
+    pub fn from_base64(media_type: String, base64: String) -> Self {
+        Self {
+            inner: BamlMedia::base64(BamlMediaType::Audio, base64, Some(media_type)),
+        }
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("Audio", class::object())?;
+        cls.define_singleton_method("from_url", function!(Audio::from_url, 2))?;
+        cls.define_singleton_method("from_base64", function!(Audio::from_base64, 2))?;
+
+        Ok(())
+    }
+}
+
+impl CloneAsBamlValue for Audio {
+    fn clone_as_baml_value(&self) -> BamlValue {
+        BamlValue::Media(self.inner.clone())
+    }
+}
+
+#[magnus::wrap(class = "Baml::Ffi::Pdf", free_immediately, size)]
+pub(crate) struct Pdf {
+    pub(crate) inner: BamlMedia,
+}
+
+impl Pdf {
+    pub fn from_url(url: String) -> Self {
+        Self {
+            inner: BamlMedia::url(BamlMediaType::Pdf, url, Some("application/pdf".to_string())),
+        }
+    }
+
+    pub fn from_base64(base64: String) -> Self {
+        Self {
+            inner: BamlMedia::base64(
+                BamlMediaType::Pdf,
+                base64,
+                Some("application/pdf".to_string()),
+            ),
+        }
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("Pdf", class::object())?;
+        cls.define_singleton_method("from_url", function!(Pdf::from_url, 1))?;
+        cls.define_singleton_method("from_base64", function!(Pdf::from_base64, 1))?;
+
+        Ok(())
+    }
+}
+
+impl CloneAsBamlValue for Pdf {
+    fn clone_as_baml_value(&self) -> BamlValue {
+        BamlValue::Media(self.inner.clone())
+    }
+}
+
+#[magnus::wrap(class = "Baml::Ffi::Video", free_immediately, size)]
+pub(crate) struct Video {
+    pub(crate) inner: BamlMedia,
+}
+
+impl Video {
+    pub fn from_url(url: String, media_type: Option<String>) -> Self {
+        Self {
+            inner: BamlMedia::url(BamlMediaType::Video, url, media_type),
+        }
+    }
+    pub fn from_base64(media_type: String, base64: String) -> Self {
+        Self {
+            inner: BamlMedia::base64(BamlMediaType::Video, base64, Some(media_type)),
+        }
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("Video", class::object())?;
+        cls.define_singleton_method("from_url", function!(Video::from_url, 2))?;
+        cls.define_singleton_method("from_base64", function!(Video::from_base64, 2))?;
+
+        Ok(())
+    }
+}
+
+impl CloneAsBamlValue for Video {
+    fn clone_as_baml_value(&self) -> BamlValue {
+        BamlValue::Media(self.inner.clone())
+    }
+}

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

@@ -0,0 +1,8 @@
+pub(crate) mod client_registry;
+mod lang_wrapper;
+pub(crate) mod log_collector;
+pub(crate) mod media;
+pub(crate) mod request;
+pub(crate) mod response;
+pub(crate) mod runtime_ctx_manager;
+pub(crate) mod type_builder;

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

@@ -0,0 +1,107 @@
+use magnus::{class, method, r_array::TypedArray, Error, Module, RModule, Ruby};
+
+use crate::Result;
+
+crate::lang_wrapper!(
+    HTTPRequest,
+    "Baml::Ffi::HTTPRequest",
+    baml_types::tracing::events::HTTPRequest,
+    clone_safe
+);
+
+crate::lang_wrapper!(
+    HTTPBody,
+    "Baml::Ffi::HTTPBody",
+    baml_types::tracing::events::HTTPBody,
+    clone_safe
+);
+
+impl HTTPRequest {
+    pub fn to_s(&self) -> String {
+        format!(
+            "HTTPRequest(url={}, method={}, headers={}, body={})",
+            self.inner.url(),
+            self.inner.method(),
+            serde_json::to_string_pretty(&self.inner.headers()).unwrap_or_default(),
+            serde_json::to_string_pretty(&self.inner.body().as_serde_value()).unwrap_or_default()
+        )
+    }
+
+    pub fn id(&self) -> String {
+        self.inner.id().to_string()
+    }
+
+    pub fn url(&self) -> String {
+        self.inner.url().to_string()
+    }
+
+    pub fn method(&self) -> String {
+        self.inner.method().to_string()
+    }
+
+    pub fn headers(ruby: &Ruby, rb_self: &Self) -> Result<magnus::Value> {
+        // Convert headers to Ruby hash
+        serde_magnus::serialize(&rb_self.inner.headers())
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e:?}")))
+    }
+
+    pub fn body(&self) -> HTTPBody {
+        // TODO: Avoid clone.
+        HTTPBody::from(self.inner.body().clone())
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("HTTPRequest", class::object())?;
+
+        cls.define_method("to_s", method!(HTTPRequest::to_s, 0))?;
+        cls.define_method("id", method!(HTTPRequest::id, 0))?;
+        cls.define_method("url", method!(HTTPRequest::url, 0))?;
+        cls.define_method("method", method!(HTTPRequest::method, 0))?;
+        cls.define_method("headers", method!(HTTPRequest::headers, 0))?;
+        cls.define_method("body", method!(HTTPRequest::body, 0))?;
+
+        Ok(())
+    }
+}
+
+impl HTTPBody {
+    pub fn raw(ruby: &Ruby, rb_self: &Self) -> Result<TypedArray<u8>> {
+        let array = ruby.typed_ary_new();
+
+        // TODO: Can we avoid cloning or at least do this faster than byte by
+        // byte?
+        for byte in rb_self.inner.raw() {
+            array.push(*byte)?;
+        }
+
+        Ok(array)
+    }
+
+    pub fn text(ruby: &Ruby, rb_self: &Self) -> Result<String> {
+        rb_self.inner.text().map(String::from).map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to get text from HTTP body:\n{e:?}"),
+            )
+        })
+    }
+
+    pub fn json(ruby: &Ruby, rb_self: &Self) -> Result<magnus::Value> {
+        serde_magnus::serialize(&rb_self.inner.json().map_err(|e| {
+            Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed deserializing HTTP body as JSON:\n{e:?}"),
+            )
+        })?)
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("HTTPBody", class::object())?;
+
+        cls.define_method("raw", method!(HTTPBody::raw, 0))?;
+        cls.define_method("text", method!(HTTPBody::text, 0))?;
+        cls.define_method("json", method!(HTTPBody::json, 0))?;
+
+        Ok(())
+    }
+}

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

@@ -0,0 +1,48 @@
+use magnus::{class, method, Error, Module, RModule, Ruby};
+
+use super::request::HTTPBody;
+use crate::Result;
+
+crate::lang_wrapper!(
+    HTTPResponse,
+    "Baml::Ffi::HTTPResponse",
+    baml_types::tracing::events::HTTPResponse,
+    clone_safe
+);
+
+impl HTTPResponse {
+    pub fn to_s(&self) -> String {
+        format!(
+            "HTTPResponse(status={}, headers={}, body={})",
+            self.inner.status,
+            serde_json::to_string_pretty(&self.inner.headers()).unwrap_or_default(),
+            serde_json::to_string_pretty(&self.inner.body.as_serde_value()).unwrap_or_default()
+        )
+    }
+
+    pub fn status(&self) -> u16 {
+        self.inner.status
+    }
+
+    pub fn headers(ruby: &Ruby, rb_self: &Self) -> Result<magnus::Value> {
+        // Convert headers to Ruby hash
+        serde_magnus::serialize(&rb_self.inner.headers())
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{e:?}")))
+    }
+
+    pub fn body(&self) -> HTTPBody {
+        // TODO: Avoid clone.
+        HTTPBody::from(self.inner.body.clone())
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("HTTPResponse", class::object())?;
+
+        cls.define_method("to_s", method!(HTTPResponse::to_s, 0))?;
+        cls.define_method("status", method!(HTTPResponse::status, 0))?;
+        cls.define_method("headers", method!(HTTPResponse::headers, 0))?;
+        cls.define_method("body", method!(HTTPResponse::body, 0))?;
+
+        Ok(())
+    }
+}

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

@@ -0,0 +1,18 @@
+use magnus::{class, prelude::*, RModule};
+
+use crate::Result;
+
+#[magnus::wrap(class = "Baml::Ffi::RuntimeContextManager", free_immediately, size)]
+pub struct RuntimeContextManager {
+    pub inner: baml_runtime::RuntimeContextManager,
+}
+impl RuntimeContextManager {
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        module.define_class("RuntimeContextManager", class::object())?;
+
+        //cls.define_method("upsert_tags", method!(RuntimeContextManager::upsert_tags, 1))?;
+        //cls.define_method("deep_clone", method!(RuntimeContextManager::deep_clone, 0))?;
+
+        Ok(())
+    }
+}

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

@@ -0,0 +1,334 @@
+#![allow(dead_code)]
+
+use baml_runtime::type_builder::{self, WithMeta};
+use baml_types::{ir_type::UnionConstructor, BamlValue};
+use magnus::{
+    class, function, method, scan_args::scan_args, try_convert::TryConvertOwned, Module, Object,
+    RModule, Value,
+};
+
+use crate::Result;
+
+#[magnus::wrap(class = "Baml::Ffi::TypeBuilder", free_immediately, size)]
+pub(crate) struct TypeBuilder {
+    pub(crate) inner: type_builder::TypeBuilder,
+}
+
+crate::lang_wrapper!(EnumBuilder, "Baml::Ffi::EnumBuilder", type_builder::EnumBuilder, sync_thread_safe, name: String);
+crate::lang_wrapper!(ClassBuilder, "Baml::Ffi::ClassBuilder", type_builder::ClassBuilder, sync_thread_safe, name: String);
+crate::lang_wrapper!(
+    EnumValueBuilder,
+    "Baml::Ffi::EnumValueBuilder",
+    type_builder::EnumValueBuilder,
+    sync_thread_safe
+);
+crate::lang_wrapper!(
+    ClassPropertyBuilder,
+    "Baml::Ffi::ClassPropertyBuilder",
+    type_builder::ClassPropertyBuilder,
+    sync_thread_safe
+);
+crate::lang_wrapper!(
+    FieldType,
+    "Baml::Ffi::FieldType",
+    baml_types::TypeIR,
+    sync_thread_safe
+);
+
+impl TypeBuilder {
+    pub fn new() -> Self {
+        Self {
+            inner: type_builder::TypeBuilder::new(),
+        }
+    }
+
+    pub fn reset(&self) {
+        self.inner.reset();
+    }
+
+    pub fn r#enum(&self, name: String) -> EnumBuilder {
+        EnumBuilder {
+            inner: self.inner.upsert_enum(name.as_str()),
+            name: name.to_string(),
+        }
+    }
+
+    pub fn class(&self, name: String) -> ClassBuilder {
+        ClassBuilder {
+            inner: self.inner.upsert_class(name.as_str()),
+            name: name.to_string(),
+        }
+    }
+
+    pub fn list(&self, inner: &FieldType) -> FieldType {
+        inner.inner.lock().unwrap().clone().as_list().into()
+    }
+
+    pub fn optional(&self, inner: &FieldType) -> FieldType {
+        inner.inner.lock().unwrap().clone().as_optional().into()
+    }
+
+    pub fn string(&self) -> FieldType {
+        baml_types::TypeIR::string().into()
+    }
+
+    pub fn literal_string(&self, value: String) -> FieldType {
+        baml_types::TypeIR::literal_string(value).into()
+    }
+
+    pub fn literal_int(&self, value: i64) -> FieldType {
+        baml_types::TypeIR::literal_int(value).into()
+    }
+
+    pub fn literal_bool(&self, value: bool) -> FieldType {
+        baml_types::TypeIR::literal_bool(value).into()
+    }
+
+    pub fn int(&self) -> FieldType {
+        baml_types::TypeIR::int().into()
+    }
+
+    pub fn float(&self) -> FieldType {
+        baml_types::TypeIR::float().into()
+    }
+
+    pub fn bool(&self) -> FieldType {
+        baml_types::TypeIR::bool().into()
+    }
+
+    pub fn null(&self) -> FieldType {
+        baml_types::TypeIR::null().into()
+    }
+
+    pub fn map(&self, key: &FieldType, value: &FieldType) -> FieldType {
+        baml_types::TypeIR::map(
+            key.inner.lock().unwrap().clone(),
+            value.inner.lock().unwrap().clone(),
+        )
+        .into()
+    }
+
+    pub fn union(&self, args: &[Value]) -> Result<FieldType> {
+        let args = scan_args::<(), (), _, (), (), ()>(args)?;
+        let types: Vec<&FieldType> = args.splat;
+        Ok(baml_types::TypeIR::union(
+            types
+                .into_iter()
+                .map(|t| t.inner.lock().unwrap().clone())
+                .collect(),
+        )
+        .into())
+    }
+
+    pub fn add_baml(
+        ruby: &magnus::Ruby,
+        rb_self: &TypeBuilder,
+        baml: String,
+        runtime: &crate::BamlRuntimeFfi,
+    ) -> Result<()> {
+        rb_self
+            .inner
+            .add_baml(&baml, runtime.inner.internal())
+            .map_err(|e| magnus::Error::new(ruby.exception_runtime_error(), e.to_string()))
+    }
+
+    // this implements ruby's friendly to_s method for converting objects to strings
+    // when someone calls .to_s on a typebuilder in ruby, this method gets called
+    // under the hood, it uses rust's display trait to format everything nicely
+    // by using the same display logic across languages, we keep things consistent
+    // this helps make debugging and logging work the same way everywhere :D
+    pub fn to_s(&self) -> String {
+        self.inner.to_string()
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("TypeBuilder", class::object())?;
+
+        cls.define_singleton_method("new", function!(TypeBuilder::new, 0))?;
+        cls.define_method("to_s", method!(TypeBuilder::to_s, 0))?;
+        cls.define_method("enum", method!(TypeBuilder::r#enum, 1))?;
+        // TODO: Not exposed, Ruby doesn't work right now.
+        // cls.define_method("reset", method!(TypeBuilder::reset, 0))?;
+        // "class" is used by Kernel: https://ruby-doc.org/core-3.0.2/Kernel.html#method-i-class
+        cls.define_method("class_", method!(TypeBuilder::class, 1))?;
+        cls.define_method("list", method!(TypeBuilder::list, 1))?;
+        cls.define_method("optional", method!(TypeBuilder::optional, 1))?;
+        cls.define_method("string", method!(TypeBuilder::string, 0))?;
+        cls.define_method("int", method!(TypeBuilder::int, 0))?;
+        cls.define_method("float", method!(TypeBuilder::float, 0))?;
+        cls.define_method("bool", method!(TypeBuilder::bool, 0))?;
+        cls.define_method("null", method!(TypeBuilder::null, 0))?;
+        cls.define_method("map", method!(TypeBuilder::map, 2))?;
+        cls.define_method("union", method!(TypeBuilder::union, -1))?;
+        cls.define_method("literal_string", method!(TypeBuilder::literal_string, 1))?;
+        cls.define_method("literal_int", method!(TypeBuilder::literal_int, 1))?;
+        cls.define_method("literal_bool", method!(TypeBuilder::literal_bool, 1))?;
+        cls.define_method("add_baml", method!(TypeBuilder::add_baml, 2))?;
+
+        Ok(())
+    }
+}
+
+impl FieldType {
+    pub fn list(&self) -> FieldType {
+        self.inner.lock().unwrap().clone().as_list().into()
+    }
+
+    pub fn optional(&self) -> FieldType {
+        self.inner.lock().unwrap().clone().as_optional().into()
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("FieldType", class::object())?;
+
+        cls.define_method("list", method!(FieldType::list, 0))?;
+        cls.define_method("optional", method!(FieldType::optional, 0))?;
+
+        Ok(())
+    }
+}
+
+// magnus makes it non-ergonomic to convert a ScanArgsSplat into a Vec<&T> because Vec puts
+// stuff on the heap, and moving Ruby-owned objects to the heap is very unsafe. It does so
+// by bounding ScanArgsSplat using TryConvertOwned, which is not implemented for &TypedData,
+// so we have to implement it ourselves. This is perfectly safe to do because FieldType does
+// not have any references to Ruby objects.
+unsafe impl TryConvertOwned for &FieldType {}
+
+impl EnumBuilder {
+    pub fn value(&self, name: String) -> EnumValueBuilder {
+        self.inner
+            .lock()
+            .unwrap()
+            .upsert_value(name.as_str())
+            .into()
+    }
+
+    pub fn alias(&self, alias: Option<String>) -> Self {
+        self.inner.lock().unwrap().with_meta(
+            "alias",
+            alias.map_or(baml_types::BamlValue::Null, BamlValue::String),
+        );
+        self.inner.clone().into()
+    }
+
+    pub fn field(&self) -> FieldType {
+        baml_types::TypeIR::r#enum(&self.name).into()
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("EnumBuilder", class::object())?;
+
+        cls.define_method("value", method!(EnumBuilder::value, 1))?;
+        cls.define_method("alias", method!(EnumBuilder::alias, 1))?;
+        cls.define_method("field", method!(EnumBuilder::field, 0))?;
+
+        Ok(())
+    }
+}
+
+impl EnumValueBuilder {
+    pub fn alias(&self, alias: Option<String>) -> Self {
+        self.inner.lock().unwrap().with_meta(
+            "alias",
+            alias.map_or(baml_types::BamlValue::Null, BamlValue::String),
+        );
+        self.inner.clone().into()
+    }
+
+    pub fn skip(&self, skip: Option<bool>) -> Self {
+        self.inner
+            .lock()
+            .unwrap()
+            .with_meta("skip", skip.map_or(BamlValue::Null, BamlValue::Bool));
+        self.inner.clone().into()
+    }
+
+    pub fn description(&self, description: Option<String>) -> Self {
+        self.inner.lock().unwrap().with_meta(
+            "description",
+            description.map_or(baml_types::BamlValue::Null, BamlValue::String),
+        );
+        self.inner.clone().into()
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("EnumValueBuilder", class::object())?;
+
+        cls.define_method("alias", method!(EnumValueBuilder::alias, 1))?;
+        cls.define_method("skip", method!(EnumValueBuilder::skip, 1))?;
+        cls.define_method("description", method!(EnumValueBuilder::description, 1))?;
+
+        Ok(())
+    }
+}
+
+impl ClassBuilder {
+    pub fn reset(&self) {
+        self.inner.lock().unwrap().reset();
+    }
+
+    pub fn remove_property(&self, name: String) {
+        self.inner.lock().unwrap().remove_property(name.as_str());
+    }
+
+    pub fn field(&self) -> FieldType {
+        baml_types::TypeIR::class(&self.name).into()
+    }
+
+    pub fn property(&self, name: String) -> ClassPropertyBuilder {
+        self.inner
+            .lock()
+            .unwrap()
+            .upsert_property(name.as_str())
+            .into()
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("ClassBuilder", class::object())?;
+
+        cls.define_method("field", method!(ClassBuilder::field, 0))?;
+        cls.define_method("property", method!(ClassBuilder::property, 1))?;
+        // TODO: Not exposed, Ruby doesn't work right now.
+        // cls.define_method("reset", method!(ClassBuilder::reset, 0))?;
+        // cls.define_method("remove_property", method!(ClassBuilder::remove_property, 1))?;
+
+        Ok(())
+    }
+}
+
+impl ClassPropertyBuilder {
+    pub fn r#type(&self, r#type: &FieldType) -> Self {
+        self.inner
+            .lock()
+            .unwrap()
+            .set_type(r#type.inner.lock().unwrap().clone());
+        self.inner.clone().into()
+    }
+
+    pub fn alias(&self, alias: Option<String>) -> Self {
+        self.inner.lock().unwrap().with_meta(
+            "alias",
+            alias.map_or(baml_types::BamlValue::Null, BamlValue::String),
+        );
+        self.inner.clone().into()
+    }
+
+    pub fn description(&self, description: Option<String>) -> Self {
+        self.inner.lock().unwrap().with_meta(
+            "description",
+            description.map_or(baml_types::BamlValue::Null, BamlValue::String),
+        );
+        self.inner.clone().into()
+    }
+
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("ClassPropertyBuilder", class::object())?;
+
+        cls.define_method("type", method!(ClassPropertyBuilder::r#type, 1))?;
+        cls.define_method("alias", method!(ClassPropertyBuilder::alias, 1))?;
+        cls.define_method("description", method!(ClassPropertyBuilder::description, 1))?;
+
+        Ok(())
+    }
+}