Sam/backend endpoints

engine/Cargo.toml

@@ -3,6 +3,7 @@ resolver = "2"
 members = [
   "baml-lib/*",
   "baml-runtime",
+  "baml-rpc",
   "baml-schema-wasm",
   "bstd",
   "cli",
@@ -15,6 +16,7 @@ members = [
 default-members = [
   "baml-lib/*",
   "baml-runtime",
+  "baml-rpc",
   # Disabled by default: --features no_wasm and --features wasm are mutually exclusive
   # Building baml-schema-wasm in combination with everything else triggers feature unification,
   # and it's OK to not build this by default because we have to build ts separately (this may
@@ -55,6 +57,8 @@ internal-baml-core = { path = "baml-lib/baml-core" }
 internal-baml-jinja = { path = "baml-lib/jinja-runtime" }
 internal-baml-schema-ast = { path = "baml-lib/schema-ast" }
 internal-llm-client = { path = "baml-lib/llm-client" }
+baml-runtime = { path = "baml-runtime" }
+
 log = "0.4.20"
 # TODO: disable imports, etc
 minijinja = { version = "1.0.16", default-features = false, features = [

engine/baml-lib/baml-core/Cargo.toml

@@ -48,3 +48,5 @@ dissimilar = "1.0.4"
 expect-test = "1.1.0"
 indoc.workspace = true
 either = "1.8.1"
+diff = "*"
+colored = "*"

engine/baml-lib/baml-core/src/ir/mod.rs

@@ -3,6 +3,7 @@ pub mod jinja_helpers;
 mod json_schema;
 pub mod repr;
 mod walker;
+pub mod signature;
 
 pub use ir_helpers::{
     scope_diagnostics, ArgCoercer, ClassFieldWalker, ClassWalker, ClientWalker, EnumValueWalker,

engine/baml-lib/baml-core/src/ir/repr.rs

@@ -22,21 +22,21 @@ use internal_baml_schema_ast::ast::{
 use internal_llm_client::{ClientProvider, ClientSpec, UnresolvedClientProperty};
 use serde::Serialize;
 
+use crate::ir::signature::{BamlHash, ProvideBamlHash};
 use crate::Configuration;
-
 /// This class represents the intermediate representation of the BAML AST.
 /// It is a representation of the BAML AST that is easier to work with than the
 /// raw BAML AST, and should include all information necessary to generate
 /// code in any target language.
 #[derive(Debug)]
 pub struct IntermediateRepr {
-    enums: Vec<Node<Enum>>,
-    classes: Vec<Node<Class>>,
-    type_aliases: Vec<Node<TypeAlias>>,
-    functions: Vec<Node<Function>>,
-    clients: Vec<Node<Client>>,
-    retry_policies: Vec<Node<RetryPolicy>>,
-    template_strings: Vec<Node<TemplateString>>,
+    pub(super) enums: Vec<Node<Enum>>,
+    pub(super) classes: Vec<Node<Class>>,
+    pub(super) type_aliases: Vec<Node<TypeAlias>>,
+    pub(super) functions: Vec<Node<Function>>,
+    pub(super) clients: Vec<Node<Client>>,
+    pub(super) retry_policies: Vec<Node<RetryPolicy>>,
+    pub(super) template_strings: Vec<Node<TemplateString>>,
 
     /// Strongly connected components of the dependency graph (finite cycles).
     finite_recursive_cycles: Vec<IndexSet<String>>,
@@ -1243,6 +1243,32 @@ pub struct Client {
     pub options: UnresolvedClientProperty<()>,
 }
 
+impl Client {
+    pub fn names(&self) -> std::collections::HashSet<String> {
+        let mut names = std::collections::HashSet::new();
+
+        self.retry_policy_id.as_ref().map(|id| {
+            names.insert(id.clone());
+        });
+
+        match &self.options {
+            UnresolvedClientProperty::OpenAI(..)
+            | UnresolvedClientProperty::Anthropic(..)
+            | UnresolvedClientProperty::AWSBedrock(..)
+            | UnresolvedClientProperty::Vertex(..)
+            | UnresolvedClientProperty::GoogleAI(..) => {}
+            UnresolvedClientProperty::RoundRobin(options) => {
+                names.extend(options.names());
+            }
+            UnresolvedClientProperty::Fallback(options) => {
+                names.extend(options.names());
+            }
+        }
+
+        names
+    }
+}
+
 impl WithRepr<Client> for ClientWalker<'_> {
     fn attributes(&self, _: &ParserDatabase) -> NodeAttributes {
         NodeAttributes {

engine/baml-lib/baml-core/src/ir/signature.rs

@@ -0,0 +1,110 @@
+use baml_types::{Resolvable, StringOr};
+
+mod r#enum;
+mod class;
+mod template_string;
+mod test_case;
+mod client;
+mod function;
+mod type_alias;
+mod retry_policy;
+mod runtime;
+/// Used to identify unique signatures of types.
+
+trait Signature {
+    fn type_name(&self) -> &'static str;
+    // Returns the interface of the type and its named-dependencies
+    fn interface(&self) -> Option<String>;
+    // Returns the impl of the type and its named-dependencies
+    fn impl_(&self) -> Option<String> {
+        None
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct BamlHash {
+    type_name: &'static str,
+    interface_hash: Option<u64>,
+    impl_hash: Option<u64>,
+}
+
+
+pub trait ProvideBamlHash {
+    fn to_baml_hash(&self) -> BamlHash;
+}
+
+fn hash_string(type_name: &str, s: &str) -> u64 {
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    std::hash::Hash::hash(&(type_name, s), &mut hasher);
+    std::hash::Hasher::finish(&hasher)
+}
+
+impl<T: Signature> ProvideBamlHash for T {
+    fn to_baml_hash(&self) -> BamlHash {
+        BamlHash {
+            type_name: self.type_name(),
+            interface_hash: self.interface().map(|s| hash_string(self.type_name(), &s)),
+            impl_hash: self.impl_().map(|s| hash_string(self.type_name(), &s)),
+        }
+    }
+}
+
+impl<Meta> Signature for Resolvable<StringOr, Meta> {
+    fn type_name(&self) -> &'static str {
+        match self {
+            Resolvable::String(s, _) => s.type_name(),
+            Resolvable::Numeric(n, _) => "numeric",
+            Resolvable::Bool(b, _) => "bool",
+            Resolvable::Array(_, _) => "array",
+            Resolvable::Map(_, _) => "map",
+            Resolvable::Null(_) => "null",
+        }
+    }
+
+    fn interface(&self) -> Option<String> {
+        match self {
+            Resolvable::String(value, _) => value.interface(),
+            Resolvable::Numeric(value, _) => Some(value.to_string()),
+            Resolvable::Bool(value, _) => Some(value.to_string()),
+            Resolvable::Array(resolvables, _) => Some(resolvables
+                .iter()
+                .filter_map(|r| r.interface())
+                .collect::<Vec<_>>()
+                .join("_BAML_ARRAY_")),
+            Resolvable::Map(index_map, _) => Some(index_map
+                .iter()
+                .filter_map(|(k, (_, v))| v.interface().map(|s| format!("{}: {}", k, s)))
+                .collect::<Vec<_>>()
+                .join("_BAML_MAP_")),
+            Resolvable::Null(_) => Some("null".to_string()),
+        }
+    }
+}
+
+impl Signature for StringOr {
+    fn type_name(&self) -> &'static str {
+        match self {
+            StringOr::EnvVar(_) => "env_var",
+            StringOr::Value(_) => "value",
+            StringOr::JinjaExpression(j) => j.type_name(),
+        }
+    }
+
+    fn interface(&self) -> Option<String> {
+        match self {
+            StringOr::EnvVar(name) => Some(name.clone()),
+            StringOr::Value(value) => Some(value.clone()),
+            StringOr::JinjaExpression(expression) => expression.interface(),
+        }
+    }
+}
+
+impl Signature for baml_types::JinjaExpression {
+    fn type_name(&self) -> &'static str {
+        "jinja_expression"
+    }
+
+    fn interface(&self) -> Option<String> {
+        Some(self.to_string())
+    }
+}