Add __baml_class__ and __baml_enum__ keys into parsed maps

Author: emilsoman

README.md

@@ -6,11 +6,13 @@ Uses the BAML Rust NIF to call the BAML library.
 What this library does:
 
 - Call functions in BAML files.
-- Make use of the BAML LLM client to call LLM functions.
+- Switch between different LLM clients.
+- Get usage data using collectors.
 
 What this library does not do:
 
-- Generate `baml_client` Elixir client code from BAML files.
+- Code generation of Elixir `baml_client` from BAML files.
+- Automatically parse BAML results into Elixir structs.
 
 ## Usage
 
@@ -54,7 +56,6 @@ function ExtractResume(resume: string) -> Resume {
 Now call the BAML function:
 
 ```elixir
-# from: The path to the baml_src directory.
 alias BamlElixir.Client
 
 Client.new()
@@ -71,6 +72,35 @@ Client.new()
 |> Enum.each(&IO.inspect/1)
 ```
 
+#### Parsing results
+
+If BAML returns a class type, you will get a map with keys as atoms and a special key `__baml_class__` with the BAML class name.
+
+Example:
+
+```elixir
+%{
+  __baml_class__: "Resume",
+  name: "John Doe",
+  job_title: "CTO",
+  company: %{
+    __baml_class__: "Company",
+    name: "Acme Inc."
+  }
+}
+```
+
+If BAML returns an enum type, you will get a map two special keys: `__baml_enum__` with the BAML enum name and `value` with the enum value.
+
+Example:
+
+```elixir
+%{
+  __baml_enum__: "Color",
+  value: "Red"
+}
+```
+
 ### Images
 
 Send an image URL:
@@ -137,7 +167,7 @@ Add baml_elixir to your mix.exs:
 ```elixir
 def deps do
   [
-    {:baml_elixir, "~> 1.0.0-pre.3"}
+    {:baml_elixir, "~> 1.0.0-pre.4"}
   ]
 end
 ```

mix.exs

@@ -1,7 +1,7 @@
 defmodule BamlElixir.MixProject do
   use Mix.Project
 
-  @version "1.0.0-pre.3"
+  @version "1.0.0-pre.4"
 
   def project do
     [

native/baml_elixir/src/lib.rs

@@ -82,7 +82,7 @@ fn baml_value_to_term<'a>(env: Env<'a>, value: &BamlValue, client: &Client) -> N
                 .collect();
             Ok(terms?.encode(env))
         }
-        BamlValue::Map(map) | BamlValue::Class(_, map) => {
+        BamlValue::Map(map) => {
             let mut result_map = Term::map_new(env);
             for (key, value) in map.iter() {
                 let value_term = baml_value_to_term(env, value, client)?;
@@ -92,18 +92,39 @@ fn baml_value_to_term<'a>(env: Env<'a>, value: &BamlValue, client: &Client) -> N
             }
             Ok(result_map)
         }
+        BamlValue::Class(class_name, map) => {
+            let mut result_map = Term::map_new(env);
+            let class_atom = rustler::Atom::from_str(env, "__baml_class__")
+                .map_err(|_| Error::Term(Box::new("Failed to create atom")))?;
+            result_map = result_map
+                .map_put(class_atom.encode(env), class_name.encode(env))
+                .map_err(|_| Error::Term(Box::new("Failed to add class name")))?;
+            for (key, value) in map.iter() {
+                let key_atom = rustler::Atom::from_str(env, key)
+                    .map_err(|_| Error::Term(Box::new("Failed to create key atom")))?;
+                let value_term = baml_value_to_term(env, value, client)?;
+                result_map = result_map
+                    .map_put(key_atom.encode(env), value_term)
+                    .map_err(|_| Error::Term(Box::new("Failed to add key to map")))?;
+            }
+            Ok(result_map)
+        }
         BamlValue::Media(_media) => {
             // For now, return an error since we need to check the actual BamlMedia structure
             Err(Error::Term(Box::new("Media type not yet supported")))
         }
         BamlValue::Enum(enum_type, variant) => {
-            // Convert enum to a map with type and variant
+            // Convert enum to a map with __baml_enum__ and value
             let mut result_map = Term::map_new(env);
+            let enum_atom = rustler::Atom::from_str(env, "__baml_enum__")
+                .map_err(|_| Error::Term(Box::new("Failed to create enum atom")))?;
+            let value_atom = rustler::Atom::from_str(env, "value")
+                .map_err(|_| Error::Term(Box::new("Failed to create value atom")))?;
             result_map = result_map
-                .map_put("type".encode(env), enum_type.encode(env))
+                .map_put(enum_atom.encode(env), enum_type.encode(env))
                 .map_err(|_| Error::Term(Box::new("Failed to add enum type")))?;
             result_map = result_map
-                .map_put("variant".encode(env), variant.encode(env))
+                .map_put(value_atom.encode(env), variant.encode(env))
                 .map_err(|_| Error::Term(Box::new("Failed to add enum variant")))?;
             Ok(result_map)
         }