baml-cc 0.208.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '03252379da1ea189a52782459ad23fa7ab7c90497788cfd81f13022510f9681f'
+  data.tar.gz: 4aeec84a0a78c3b15b60251e1b90bbafd5502284d900a779c4607677303f5b38
+SHA512:
+  metadata.gz: b53db0c22a6f99c5733247b0f3e36a90d1e13333a3d51333cd1f577f156852e6483078062e396d0d3698779b713a4b377103f8cebfdcac9138d0b9804fc7ffbe
+  data.tar.gz: aa15eedabb9dbc1454c490665edc7b6912c92af824063e94b28d267094f24a3c0534a8211ebf66e184b386879d66bcd5927c67a14617b124b24b9c0e896bd4f1

data/exe/baml

@@ -0,0 +1 @@
+baml-cli

data/exe/baml-cli

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "baml"
+
+Baml::Ffi::invoke_runtime_cli(Process.argv0, ARGV)

data/ext/ruby_ffi/Cargo.toml

@@ -0,0 +1,52 @@
+[package]
+name = "ruby_ffi"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+# This controls the name of the generated .so file
+crate-type = ["cdylib"]
+
+[lints.clippy]
+too_many_arguments = "allow"
+
+[dependencies]
+anyhow.workspace = true
+baml-cli.workspace = true
+baml-ids.workspace = true
+baml-log.workspace = true
+baml-runtime = { path = "../../../baml-runtime", features = ["internal"] }
+baml-types.workspace = true
+base64.workspace = true
+env_logger.workspace = true
+futures.workspace = true
+indexmap.workspace = true
+internal-baml-core.workspace = true
+jsonish = { path = "../../../baml-lib/jsonish" }
+log.workspace = true
+magnus = { version = "0.7.1", features = ["rb-sys"] }
+# Must be kept in sync with ../../Gemfile
+rb-sys = { version = "0.9.111", features = [
+  "global-allocator",
+  "bindgen-rbimpls",
+  "bindgen-deprecated-types",
+  "stable-api",
+  "stable-api-compiled-fallback",
+] }
+serde.workspace = true
+serde_json.workspace = true
+serde_magnus = { version = "0.9.0" }
+tokio = { version = "1", features = ["full"] }
+tracing-subscriber = { version = "0.3.18", features = [
+  "json",
+  "env-filter",
+  "valuable",
+] }
+
+[dev-dependencies.magnus]
+version = "0.7.1"
+features = ["rb-sys", "embed"]
+
+[build-dependencies]
+rb-sys-env = { version = "0.2.2" }

data/ext/ruby_ffi/build.rs

@@ -0,0 +1,21 @@
+use std::process::Command;
+
+pub fn main() {
+    // This is derived from the rustc commands that 'rake compile' runs, e.g.
+    //
+    // cargo rustc --package ruby_ffi --manifest-path /Users/sam/baml/engine/language_client_ruby/ext/ruby_ffi/Cargo.toml --target-dir /Users/sam/baml/engine/target --lib --profile release -- -C linker=clang -L native=/Users/sam/.local/share/mise/installs/ruby/3.1.6/lib -L native=/opt/homebrew/opt/gmp/lib -C link-arg=-Wl,-undefined,dynamic_lookup
+    //
+    // You need to run 'rake compile' from language_client_ruby itself to see these paths.
+
+    match Command::new("mise").args(["where", "ruby"]).output() {
+        Ok(output) => {
+            let ruby_path = String::from_utf8_lossy(&output.stdout).trim().to_string();
+            println!("cargo:rustc-link-search=native={ruby_path}/lib");
+        }
+        Err(e) => {
+            println!("cargo:rustc-warning=Failed to execute 'mise where ruby': {e}");
+        }
+    }
+
+    println!("cargo:rustc-link-arg=-Wl,-undefined,dynamic_lookup");
+}

data/ext/ruby_ffi/extconf.rb

@@ -0,0 +1,17 @@
+require "mkmf"
+require "rb_sys/mkmf"
+
+# no idea what create_rust_makefile actually takes as its arg, i thought it did
+# the below, but i don't think that's right anymore:
+#
+# create_rust_makefile takes, as its argument, ${CRATE_NAME}/${GEM_NAME} where:
+#
+#    - CRATE_NAME is the name of the crate in ext/${GEM_NAME}/Cargo.toml
+#    - GEM_NAME is the name of the gem in ext/baml
+create_rust_makefile("ruby_ffi") do |r|
+  r.extra_cargo_args += ["--package", "ruby_ffi"]
+  r.extra_rustflags = ["--cfg=tracing_unstable"]
+  r.env = {
+    "MACOSX_DEPLOYMENT_TARGET" => "10.13",
+  }
+end

data/ext/ruby_ffi/src/function_result.rs

@@ -0,0 +1,75 @@
+use magnus::{
+    class, exception::runtime_error, method, prelude::*, value::Value, Error, RModule, Ruby,
+};
+
+use crate::{ruby_to_json, Result};
+
+#[magnus::wrap(class = "Baml::Ffi::FunctionResult", free_immediately, size)]
+pub struct FunctionResult {
+    inner: baml_runtime::FunctionResult,
+}
+
+impl FunctionResult {
+    pub fn new(inner: baml_runtime::FunctionResult) -> Self {
+        Self { inner }
+    }
+
+    #[allow(dead_code)]
+    fn to_s(&self) -> String {
+        format!("{}", self.inner)
+    }
+
+    #[allow(dead_code)]
+    fn raw(&self) -> Result<String> {
+        match self.inner.content() {
+            Ok(content) => Ok(content.to_string()),
+            Err(_) => Err(Error::new(
+                runtime_error(),
+                format!("No LLM response: {}", self.inner),
+            )),
+        }
+    }
+
+    pub fn parsed_using_types(
+        ruby: &Ruby,
+        rb_self: &FunctionResult,
+        types: RModule,
+        partial_types: RModule,
+        allow_partials: bool,
+    ) -> Result<Value> {
+        let res = match rb_self.inner.result_with_constraints_content() {
+            Ok(parsed) => ruby_to_json::RubyToJson::serialize_baml(
+                ruby,
+                types,
+                partial_types,
+                allow_partials,
+                parsed.clone(),
+            )
+            .map_err(|e| {
+                magnus::Error::new(
+                    ruby.exception_type_error(),
+                    format!("failing inside parsed_using_types: {e:?}"),
+                )
+            }),
+            Err(_) => Err(Error::new(
+                ruby.exception_runtime_error(),
+                format!("Failed to parse LLM response: {}", rb_self.inner),
+            )),
+        };
+        res
+    }
+
+    /// For usage in magnus::init
+    ///
+    /// TODO: use traits and macros to implement this
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("FunctionResult", class::object())?;
+
+        cls.define_method(
+            "parsed_using_types",
+            method!(FunctionResult::parsed_using_types, 3),
+        )?;
+
+        Ok(())
+    }
+}

data/ext/ruby_ffi/src/function_result_stream.rs

@@ -0,0 +1,63 @@
+use std::{cell::RefCell, collections::HashMap, sync::Arc};
+
+use magnus::{class, method, Module, RModule, Ruby};
+
+use super::types::runtime_ctx_manager::RuntimeContextManager;
+use crate::{function_result::FunctionResult, Error, Result};
+
+#[magnus::wrap(class = "Baml::Ffi::FunctionResultStream", free_immediately, size)]
+pub struct FunctionResultStream {
+    inner: RefCell<baml_runtime::FunctionResultStream>,
+    t: Arc<tokio::runtime::Runtime>,
+}
+
+impl FunctionResultStream {
+    pub(super) fn new(
+        inner: baml_runtime::FunctionResultStream,
+        t: Arc<tokio::runtime::Runtime>,
+    ) -> Self {
+        Self {
+            inner: RefCell::new(inner),
+            t,
+        }
+    }
+
+    fn done(
+        ruby: &Ruby,
+        rb_self: &FunctionResultStream,
+        ctx: &RuntimeContextManager,
+    ) -> Result<FunctionResult> {
+        let on_event = if ruby.block_given() {
+            let proc = ruby.block_proc()?;
+            Some(move |event: baml_runtime::FunctionResult| {
+                // ignore errors if they happen
+                let _ = proc.call::<_, magnus::Value>((FunctionResult::new(event),));
+            })
+        } else {
+            None
+        };
+
+        match rb_self.t.block_on(rb_self.inner.borrow_mut().run(
+            None::<fn()>,
+            on_event,
+            &ctx.inner,
+            None,
+            None,
+            HashMap::new(),
+        )) {
+            (Ok(res), _) => Ok(FunctionResult::new(res)),
+            (Err(e), _) => Err(Error::new(ruby.exception_runtime_error(), format!("{e:?}"))),
+        }
+    }
+
+    /// For usage in magnus::init
+    ///
+    /// TODO: use traits and macros to implement this
+    pub fn define_in_ruby(module: &RModule) -> Result<()> {
+        let cls = module.define_class("FunctionResultStream", class::object())?;
+
+        cls.define_method("done", method!(FunctionResultStream::done, 1))?;
+
+        Ok(())
+    }
+}

data/ext/ruby_ffi/src/lib.rs

@@ -0,0 +1,388 @@
+use std::{collections::HashMap, path::PathBuf, sync::Arc};
+
+use baml_runtime::{BamlRuntime, TripWire};
+use baml_types::BamlValue;
+use function_result::FunctionResult;
+use function_result_stream::FunctionResultStream;
+use internal_baml_core::feature_flags::FeatureFlags;
+use magnus::{class, function, method, prelude::*, Error, RArray, RHash, RModule, Ruby};
+use types::{
+    log_collector::Collector, request::HTTPRequest, runtime_ctx_manager::RuntimeContextManager,
+};
+
+mod function_result;
+mod function_result_stream;
+mod ruby_to_json;
+mod types;
+
+type Result<T> = std::result::Result<T, magnus::Error>;
+
+// must be kept in sync with rb.define_class in the init() fn
+#[magnus::wrap(class = "Baml::Ffi::BamlRuntime", free_immediately, size)]
+struct BamlRuntimeFfi {
+    inner: Arc<BamlRuntime>,
+    t: Arc<tokio::runtime::Runtime>,
+}
+
+impl Drop for BamlRuntimeFfi {
+    fn drop(&mut self) {
+        use baml_runtime::runtime_interface::ExperimentalTracingInterface;
+        match self.inner.flush() {
+            Ok(_) => log::trace!("Flushed BAML log events"),
+            Err(e) => log::error!("Error while flushing BAML log events: {e:?}"),
+        }
+    }
+}
+
+impl BamlRuntimeFfi {
+    fn make_tokio_runtime(ruby: &Ruby) -> Result<tokio::runtime::Runtime> {
+        // NB: libruby will panic if called from a non-Ruby thread, so we stick to the current thread
+        // to avoid causing issues
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!("Failed to start tokio runtime because:\n{e:?}"),
+                )
+            })
+    }
+
+    pub fn from_directory(
+        ruby: &Ruby,
+        directory: PathBuf,
+        env_vars: HashMap<String, String>,
+    ) -> Result<BamlRuntimeFfi> {
+        let baml_runtime =
+            match BamlRuntime::from_directory(&directory, env_vars, FeatureFlags::new()) {
+                Ok(br) => br,
+                Err(e) => {
+                    return Err(Error::new(
+                        ruby.exception_runtime_error(),
+                        format!("{:?}", e.context("Failed to initialize BAML runtime")),
+                    ))
+                }
+            };
+
+        let rt = BamlRuntimeFfi {
+            inner: Arc::new(baml_runtime),
+            t: Arc::new(Self::make_tokio_runtime(ruby)?),
+        };
+
+        Ok(rt)
+    }
+
+    pub fn from_files(
+        ruby: &Ruby,
+        root_path: String,
+        files: HashMap<String, String>,
+        env_vars: HashMap<String, String>,
+    ) -> Result<Self> {
+        let baml_runtime =
+            match BamlRuntime::from_file_content(&root_path, &files, env_vars, FeatureFlags::new())
+            {
+                Ok(br) => br,
+                Err(e) => {
+                    return Err(Error::new(
+                        ruby.exception_runtime_error(),
+                        format!("{:?}", e.context("Failed to initialize BAML runtime")),
+                    ))
+                }
+            };
+
+        let rt = BamlRuntimeFfi {
+            inner: Arc::new(baml_runtime),
+            t: Arc::new(Self::make_tokio_runtime(ruby)?),
+        };
+
+        Ok(rt)
+    }
+
+    pub fn create_context_manager(&self) -> RuntimeContextManager {
+        RuntimeContextManager {
+            inner: self
+                .inner
+                .create_ctx_manager(BamlValue::String("ruby".to_string()), None),
+        }
+    }
+
+    pub fn call_function(
+        ruby: &Ruby,
+        rb_self: &BamlRuntimeFfi,
+        function_name: String,
+        args: RHash,
+        ctx: &RuntimeContextManager,
+        type_registry: Option<&types::type_builder::TypeBuilder>,
+        client_registry: Option<&types::client_registry::ClientRegistry>,
+        collector: RArray,
+        env_vars: HashMap<String, String>,
+    ) -> Result<FunctionResult> {
+        let args = match ruby_to_json::RubyToJson::convert_hash_to_json(args) {
+            Ok(args) => args.into_iter().collect(),
+            Err(e) => {
+                return Err(Error::new(
+                    ruby.exception_syntax_error(),
+                    format!("error while parsing call_function args:\n{e}"),
+                ));
+            }
+        };
+
+        let mut collectors = Vec::new();
+        for i in collector.into_iter() {
+            collectors.push(<&Collector>::try_convert(i)?.inner.clone());
+        }
+
+        let retval = match rb_self.t.block_on(rb_self.inner.call_function(
+            function_name.clone(),
+            &args,
+            &ctx.inner,
+            type_registry.map(|t| &t.inner),
+            client_registry.map(|c| c.inner.borrow_mut()).as_deref(),
+            Some(collectors),
+            env_vars,
+            TripWire::new(None),
+        )) {
+            (Ok(res), _) => Ok(FunctionResult::new(res)),
+            (Err(e), _) => Err(Error::new(
+                ruby.exception_runtime_error(),
+                format!(
+                    "{:?}",
+                    e.context(format!("error while calling {function_name}"))
+                ),
+            )),
+        };
+
+        retval
+    }
+
+    fn stream_function(
+        ruby: &Ruby,
+        rb_self: &BamlRuntimeFfi,
+        function_name: String,
+        args: RHash,
+        ctx: &RuntimeContextManager,
+        type_registry: Option<&types::type_builder::TypeBuilder>,
+        client_registry: Option<&types::client_registry::ClientRegistry>,
+        collector: RArray,
+        env_vars: HashMap<String, String>,
+    ) -> Result<FunctionResultStream> {
+        let args = match ruby_to_json::RubyToJson::convert_hash_to_json(args) {
+            Ok(args) => args.into_iter().collect(),
+            Err(e) => {
+                return Err(Error::new(
+                    ruby.exception_syntax_error(),
+                    format!("error while parsing stream_function args:\n{e}"),
+                ));
+            }
+        };
+
+        let mut collectors = Vec::new();
+        for i in collector.into_iter() {
+            collectors.push(<&Collector>::try_convert(i)?.inner.clone());
+        }
+
+        log::debug!("Streaming {function_name} with:\nargs: {args:#?}\nctx ???");
+
+        let retval = match rb_self.inner.stream_function(
+            function_name.clone(),
+            &args,
+            &ctx.inner,
+            type_registry.map(|t| &t.inner),
+            client_registry.map(|c| c.inner.borrow_mut()).as_deref(),
+            Some(collectors),
+            env_vars,
+            TripWire::new(None),
+        ) {
+            Ok(res) => Ok(FunctionResultStream::new(res, rb_self.t.clone())),
+            Err(e) => Err(Error::new(
+                ruby.exception_runtime_error(),
+                format!(
+                    "{:?}",
+                    e.context(format!("error while calling {function_name}"))
+                ),
+            )),
+        };
+
+        retval
+    }
+
+    pub fn build_request(
+        ruby: &Ruby,
+        rb_self: &BamlRuntimeFfi,
+        function_name: String,
+        args: RHash,
+        ctx: &RuntimeContextManager,
+        type_registry: Option<&types::type_builder::TypeBuilder>,
+        client_registry: Option<&types::client_registry::ClientRegistry>,
+        env_vars: HashMap<String, String>,
+        stream: bool,
+    ) -> Result<HTTPRequest> {
+        let args = match ruby_to_json::RubyToJson::convert_hash_to_json(args) {
+            Ok(args) => args.into_iter().collect(),
+            Err(e) => {
+                return Err(Error::new(
+                    ruby.exception_syntax_error(),
+                    format!("error while parsing call_function args:\n{e}"),
+                ));
+            }
+        };
+
+        rb_self
+            .inner
+            .build_request_sync(
+                function_name.clone(),
+                &args,
+                &ctx.inner,
+                type_registry.map(|t| &t.inner),
+                client_registry.map(|c| c.inner.borrow_mut()).as_deref(),
+                stream,
+                env_vars,
+            )
+            .map(HTTPRequest::from)
+            .map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!(
+                        "{:?}",
+                        e.context(format!(
+                            "error while building HTTP request for function {function_name}"
+                        ))
+                    ),
+                )
+            })
+    }
+
+    pub fn parse_llm_response(
+        ruby: &Ruby,
+        rb_self: &BamlRuntimeFfi,
+        function_name: String,
+        llm_response: String,
+        types: RModule,
+        partial_types: RModule,
+        allow_partials: bool,
+        ctx: &RuntimeContextManager,
+        type_registry: Option<&types::type_builder::TypeBuilder>,
+        client_registry: Option<&types::client_registry::ClientRegistry>,
+        env_vars: HashMap<String, String>,
+    ) -> Result<magnus::Value> {
+        let parsed = rb_self
+            .inner
+            .parse_llm_response(
+                function_name.clone(),
+                llm_response,
+                allow_partials,
+                &ctx.inner,
+                type_registry.map(|t| &t.inner),
+                client_registry.map(|c| c.inner.borrow_mut()).as_deref(),
+                env_vars,
+            )
+            .map_err(|e| {
+                Error::new(
+                    ruby.exception_runtime_error(),
+                    format!(
+                        "{:?}",
+                        e.context(format!(
+                            "error while parsing LLM response for function {function_name}"
+                        ))
+                    ),
+                )
+            })?;
+
+        ruby_to_json::RubyToJson::serialize_baml(ruby, types, partial_types, allow_partials, parsed)
+            .map_err(|e| {
+                magnus::Error::new(
+                    ruby.exception_type_error(),
+                    format!("failed coercing BAML value to Ruby value: {e:?}"),
+                )
+            })
+    }
+}
+
+fn invoke_runtime_cli(ruby: &Ruby, argv0: String, argv: Vec<String>) -> Result<u32> {
+    match baml_cli::run_cli(
+        std::iter::once(argv0).chain(argv).collect(),
+        baml_runtime::RuntimeCliDefaults {
+            output_type: baml_types::GeneratorOutputType::RubySorbet,
+        },
+    ) {
+        Ok(exit_code) => Ok(exit_code.into()),
+        Err(e) => Err(Error::new(
+            ruby.exception_runtime_error(),
+            format!(
+                "{:?}",
+                e.context("error while invoking baml-cli".to_string())
+            ),
+        )),
+    }
+}
+
+#[magnus::init(name = "ruby_ffi")]
+fn init(ruby: &Ruby) -> Result<()> {
+    baml_log::init().map_err(|e| {
+        Error::new(
+            ruby.exception_runtime_error(),
+            format!("Failed to initialize BAML logger: {e:#}"),
+        )
+    })?;
+
+    let module = ruby.define_module("Baml")?.define_module("Ffi")?;
+
+    module.define_module_function("invoke_runtime_cli", function!(invoke_runtime_cli, 2))?;
+
+    // must be kept in sync with the magnus::wrap annotation
+    let runtime_class = module.define_class("BamlRuntime", class::object())?;
+    runtime_class.define_singleton_method(
+        "from_directory",
+        function!(BamlRuntimeFfi::from_directory, 2),
+    )?;
+    runtime_class
+        .define_singleton_method("from_files", function!(BamlRuntimeFfi::from_files, 3))?;
+    runtime_class.define_method(
+        "create_context_manager",
+        method!(BamlRuntimeFfi::create_context_manager, 0),
+    )?;
+    runtime_class.define_method("call_function", method!(BamlRuntimeFfi::call_function, 7))?;
+    runtime_class.define_method(
+        "stream_function",
+        method!(BamlRuntimeFfi::stream_function, 7),
+    )?;
+    runtime_class.define_method("build_request", method!(BamlRuntimeFfi::build_request, 7))?;
+    runtime_class.define_method(
+        "parse_llm_response",
+        method!(BamlRuntimeFfi::parse_llm_response, 9),
+    )?;
+
+    FunctionResult::define_in_ruby(&module)?;
+    FunctionResultStream::define_in_ruby(&module)?;
+
+    RuntimeContextManager::define_in_ruby(&module)?;
+
+    types::type_builder::TypeBuilder::define_in_ruby(&module)?;
+    types::type_builder::EnumBuilder::define_in_ruby(&module)?;
+    types::type_builder::ClassBuilder::define_in_ruby(&module)?;
+    types::type_builder::EnumValueBuilder::define_in_ruby(&module)?;
+    types::type_builder::ClassPropertyBuilder::define_in_ruby(&module)?;
+    types::type_builder::FieldType::define_in_ruby(&module)?;
+
+    types::client_registry::ClientRegistry::define_in_ruby(&module)?;
+    types::media::Audio::define_in_ruby(&module)?;
+    types::media::Image::define_in_ruby(&module)?;
+    types::media::Pdf::define_in_ruby(&module)?;
+    types::media::Video::define_in_ruby(&module)?;
+
+    // Register the new log collector classes
+    types::log_collector::define_all_in_ruby(&module)?;
+
+    // everything below this is for our own testing purposes
+    module.define_module_function(
+        "roundtrip",
+        function!(ruby_to_json::RubyToJson::roundtrip, 1),
+    )?;
+    module.define_module_function(
+        "serialize",
+        function!(ruby_to_json::RubyToJson::serialize, 4),
+    )?;
+
+    Ok(())
+}